COMPILATION LISTING OF SEGMENT fs_acl_util_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-17_1935.87_Mon_mdt Options: optimize map 1 /* ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1983 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* ************************************************************** */ 8 9 10 /* BIM 830919 */ 11 /* MAP 831229 - fixed references to based arrays having zero elements */ 12 /* MAP 840127 - changed same references to accomodate ring 0 bug */ 13 /* - free storage allocated by hcs_$list_acl when acl_count = 0 */ 14 /* - set version in allocated structures */ 15 16 /* format: style2,indcomtxt */ 17 18 fs_acl_util_: 19 procedure; 20 /**** 21* fs_acl_util_: This procedure converts calling sequences from the old 22* acl listing sequence to the new one. As new-style calling sequences are 23* made available for the primitive objects here, the calls here can be 24* changed, and the callers of this changed to call the underlying 25* interfaces directly. This program handles segments, directories, 26* and MSF's. Other objects are hacked in suffix_XXX_. ****/ 27 28 /**** 29* All arguments are as in hcs_, msf_manager_. */ 30 31 declare Dir_name char (*) parameter; 32 declare Entryname char (*) parameter; 33 declare Area_ptr pointer parameter; 34 declare Acl_ptr pointer parameter; 35 declare Code fixed bin (35); 36 declare Desired_version char (8) aligned; 37 declare No_SysDaemon bit (1); 38 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 */ 39 40 41 42 declare old_acl_ptr pointer; 43 declare system_free_area area based (get_system_free_area_ ()); 44 declare area_ptr pointer; 45 declare user_area area based (area_ptr); 46 declare code fixed bin (35); 47 declare MSF_fcb pointer; 48 declare null_acl bit (1) aligned; 49 declare 1 null_segment_acl_array 50 dim (0:0) aligned like segment_acl_entry based (old_acl_ptr); 51 declare 1 null_general_acl_entry 52 aligned automatic dim (0:0) aligned like general_acl_entry; 53 declare 1 null_general_delete_acl_entry 54 aligned automatic dim (0:0) aligned like delete_acl_entry; 55 declare 1 null_general_extended_acl_entry 56 aligned automatic dim (0:0) aligned like general_extended_acl_entry; 57 58 declare get_system_free_area_ entry () returns (ptr); 59 declare get_user_free_area_ entry () returns (ptr); 60 61 declare ( 62 hcs_$list_acl, 63 hcs_$list_dir_acl, 64 file_manager_$list_acl 65 ) entry (char (*), char (*), ptr, ptr, ptr, fixed bin, fixed bin (35)); 66 67 declare msf_manager_$acl_list entry (ptr, ptr, ptr, ptr, fixed bin, fixed bin (35)); 68 69 declare ( 70 hcs_$add_acl_entries, 71 hcs_$add_dir_acl_entries, 72 file_manager_$add_acl_entries 73 ) entry (char (*), char (*), ptr, fixed bin, fixed bin (35)); 74 75 declare msf_manager_$acl_add entry (ptr, ptr, fixed bin, fixed bin (35)); 76 77 declare ( 78 hcs_$delete_acl_entries, 79 hcs_$delete_dir_acl_entries, 80 file_manager_$delete_acl_entries 81 ) entry (char (*), char (*), ptr, fixed bin, fixed bin (35)); 82 83 declare msf_manager_$acl_delete 84 entry (ptr, ptr, fixed bin, fixed bin (35)); 85 86 declare ( 87 hcs_$replace_acl, 88 hcs_$replace_dir_acl, 89 file_manager_$replace_acl 90 ) entry (char (*), char (*), ptr, fixed bin, bit (1), fixed bin (35)); 91 92 declare msf_manager_$acl_replace 93 entry (ptr, ptr, fixed bin, bit (1), fixed bin (35)); 94 95 declare msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); 96 declare msf_manager_$close entry (ptr); 97 98 declare cleanup condition; 99 100 101 102 /**** 103* Entrypoint -- list_segment: Lists seg acls with only REW bits. */ 104 105 list_segment: 106 entry (Dir_name, Entryname, Desired_version, Area_ptr, Acl_ptr, Code); 107 108 acl_ptr = null (); 109 Code = 0; 110 111 old_acl_ptr = null (); 112 on cleanup 113 begin; 114 if old_acl_ptr ^= null () 115 then free old_acl_ptr -> segment_acl_array; 116 old_acl_ptr = null (); 117 end; 118 119 if Desired_version ^= GENERAL_ACL_VERSION_1 & Acl_ptr = null () 120 then call BAD_VERSION; 121 122 if Acl_ptr ^= null () 123 then do; 124 acl_ptr = Acl_ptr; 125 if general_acl.version ^= GENERAL_ACL_VERSION_1 126 then call BAD_VERSION; 127 end; 128 129 call AREA_SETUP; 130 131 /**** * strategy: allocate old acl list in system_free_area_, 132* then allocate appropriately sized new structure, copy, and 133* free. */ 134 135 if acl_ptr = null () 136 then call FULL_LIST_SEG_ACL_CENSORED; 137 else call SPECIFIC_LIST_SEG_ACL_CENSORED; 138 139 return; 140 141 142 143 FULL_LIST_SEG_ACL_CENSORED: 144 procedure; 145 146 old_acl_ptr = null (); 147 call hcs_$list_acl (Dir_name, Entryname, get_system_free_area_ (), old_acl_ptr, null (), acl_count, code); 148 if code ^= 0 149 then do; 150 Code = code; 151 return; 152 end; 153 if acl_count = 0 154 then do; 155 Acl_ptr = null (); 156 if old_acl_ptr ^= null () 157 then free old_acl_ptr -> segment_acl_array; 158 return; 159 end; 160 allocate general_acl in (user_area); 161 general_acl.version = GENERAL_ACL_VERSION_1; 162 call CONVERT_OLD_XACL_LIST; /* does the free */ 163 Acl_ptr = acl_ptr; 164 return; 165 166 end FULL_LIST_SEG_ACL_CENSORED; 167 168 169 SPECIFIC_LIST_SEG_ACL_CENSORED: 170 procedure; 171 172 acl_count = general_acl.count; 173 if acl_count > 0 174 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 175 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 176 177 old_acl_ptr -> segment_acl_array (*).access_name = general_acl.entries (*).access_name; 178 call hcs_$list_acl (Dir_name, Entryname, null (), null (), old_acl_ptr, acl_count, code); 179 Code = code; /* may be problem with specific entry */ 180 call CONVERT_OLD_XACL_LIST; 181 return; 182 183 end SPECIFIC_LIST_SEG_ACL_CENSORED; 184 185 186 187 /**** * 188* add_segment: sets only raw acl bits for segments. */ 189 190 add_segment: 191 entry (Dir_name, Entryname, Acl_ptr, Code); 192 193 Code = 0; 194 acl_ptr = Acl_ptr; 195 old_acl_ptr = null (); 196 on cleanup 197 begin; 198 if old_acl_ptr ^= null () 199 then free old_acl_ptr -> segment_acl_array; 200 old_acl_ptr = null (); 201 end; 202 203 if acl_ptr = null () 204 then call NULL_INPUT_PTR; 205 206 if general_acl.version ^= GENERAL_ACL_VERSION_1 207 then call BAD_VERSION; 208 209 210 acl_count = general_acl.count; 211 if acl_count > 0 212 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 213 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 214 215 old_acl_ptr -> segment_acl_array (*) = general_acl.entries (*), by name; 216 old_acl_ptr -> segment_acl_array (*).extended_mode = ""b; 217 call hcs_$add_acl_entries (Dir_name, Entryname, old_acl_ptr, acl_count, code); 218 219 if acl_count > 0 220 then general_acl.entries (*).status_code = old_acl_ptr -> segment_acl_array (*).status_code; 221 free old_acl_ptr -> segment_acl_array; 222 Code = code; 223 return; 224 225 226 227 /**** 228* list_segment_extended_acl: This entrypoint supports the inner ring programs 229* that implement extended objects, by allowing them to list the acl 230* with xacl bits. */ 231 232 list_segment_extended: 233 entry (Dir_name, Entryname, Desired_version, Area_ptr, Acl_ptr, Code); 234 235 acl_ptr = null (); 236 Code = 0; 237 238 old_acl_ptr = null (); 239 on cleanup 240 begin; 241 if old_acl_ptr ^= null () 242 then free old_acl_ptr -> segment_acl_array; 243 old_acl_ptr = null (); 244 end; 245 246 if Desired_version ^= GENERAL_EXTENDED_ACL_VERSION_1 & Acl_ptr = null () 247 then call BAD_VERSION; 248 249 if Acl_ptr ^= null () 250 then do; 251 acl_ptr = Acl_ptr; 252 if general_extended_acl.version ^= GENERAL_EXTENDED_ACL_VERSION_1 253 then call BAD_VERSION; 254 end; 255 256 call AREA_SETUP; 257 258 if acl_ptr = null () 259 then call FULL_LIST_SEG_ACL; 260 else call SPECIFIC_LIST_SEG_ACL; 261 262 return; 263 264 265 266 FULL_LIST_SEG_ACL: 267 procedure; 268 269 /**** 270* Here all we have to do is copy data from array to refer extent. */ 271 272 call hcs_$list_acl (Dir_name, Entryname, get_system_free_area_ (), old_acl_ptr, null (), acl_count, code); 273 if code ^= 0 274 then do; 275 Code = code; 276 return; 277 end; 278 279 if acl_count = 0 280 then do; 281 Acl_ptr = null (); 282 if old_acl_ptr ^= null () 283 then free old_acl_ptr -> segment_acl_array; 284 return; 285 end; 286 287 allocate general_extended_acl in (user_area); 288 general_extended_acl.version = GENERAL_EXTENDED_ACL_VERSION_1; 289 general_extended_acl.entries (*) = old_acl_ptr -> segment_acl_array (*); 290 free old_acl_ptr -> segment_acl_array; 291 Acl_ptr = acl_ptr; 292 return; 293 end FULL_LIST_SEG_ACL; 294 295 296 SPECIFIC_LIST_SEG_ACL: 297 procedure; 298 299 acl_count = general_extended_acl.count; 300 if acl_count > 0 301 then call hcs_$list_acl (Dir_name, Entryname, null (), null (), addr (general_extended_acl.entries), 302 acl_count, Code); 303 else call hcs_$list_acl (Dir_name, Entryname, null (), null (), addr (null_general_extended_acl_entry), 304 0, Code); 305 306 return; 307 end SPECIFIC_LIST_SEG_ACL; 308 309 310 311 /**** 312* add_segment_extended: adds entries allowing specification of the xacl bits. */ 313 314 add_segment_extended: 315 entry (Dir_name, Entryname, Acl_ptr, Code); 316 317 Code = 0; 318 if Acl_ptr = null () 319 then call NULL_INPUT_PTR; 320 321 acl_ptr = Acl_ptr; 322 if general_extended_acl.version ^= GENERAL_EXTENDED_ACL_VERSION_1 323 then call BAD_VERSION; 324 325 if general_extended_acl.count > 0 326 then call hcs_$add_acl_entries (Dir_name, Entryname, addr (general_extended_acl.entries), 327 general_extended_acl.count, Code); 328 else call hcs_$add_acl_entries (Dir_name, Entryname, addr (null_general_extended_acl_entry), 329 0, Code); 330 return; 331 332 333 334 replace_segment: 335 entry (Dir_name, Entryname, Acl_ptr, No_SysDaemon, Code); 336 337 Code = 0; 338 old_acl_ptr = null (); 339 on cleanup 340 begin; 341 if old_acl_ptr ^= null () 342 then free old_acl_ptr -> segment_acl_array; 343 old_acl_ptr = null (); 344 end; 345 if Acl_ptr = null () 346 then 347 REPLACE_NULL_SEGMENT: 348 do; 349 call hcs_$replace_acl (Dir_name, Entryname, null (), (0), No_SysDaemon, Code); 350 return; 351 end; 352 353 acl_ptr = Acl_ptr; 354 if general_acl.version ^= GENERAL_ACL_VERSION_1 355 then call BAD_VERSION; 356 357 acl_count = general_acl.count; 358 359 if acl_count > 0 360 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 361 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 362 363 old_acl_ptr -> segment_acl_array (*).extended_mode = ""b; 364 old_acl_ptr -> segment_acl_array (*) = general_acl.entries (*), by name; 365 366 call hcs_$replace_acl (Dir_name, Entryname, old_acl_ptr, acl_count, No_SysDaemon, Code); 367 368 if acl_count > 0 369 then general_acl.entries (*).status_code = old_acl_ptr -> segment_acl_array (*).status_code; 370 free old_acl_ptr -> segment_acl_array; 371 return; 372 373 374 375 /**** 376* replace_segment_extended: like add_segment_extended */ 377 378 replace_segment_extended: 379 entry (Dir_name, Entryname, Acl_ptr, No_SysDaemon, Code); 380 381 Code = 0; 382 if Acl_ptr = null () 383 then go to REPLACE_NULL_SEGMENT; 384 385 acl_ptr = Acl_ptr; 386 if general_extended_acl.version ^= GENERAL_EXTENDED_ACL_VERSION_1 387 then call BAD_VERSION; 388 389 if general_extended_acl.count > 0 390 then call hcs_$replace_acl (Dir_name, Entryname, addr (general_extended_acl.entries), general_extended_acl.count, 391 No_SysDaemon, Code); 392 else call hcs_$replace_acl (Dir_name, Entryname, addr (null_general_extended_acl_entry), 0, 393 No_SysDaemon, Code); 394 395 return; 396 397 398 399 /**** 400* delete_segment: deletes segment acl's */ 401 402 delete_segment: 403 entry (Dir_name, Entryname, Acl_ptr, Code); 404 405 Code = 0; 406 407 if Acl_ptr = null () 408 then call NULL_INPUT_PTR; 409 acl_ptr = Acl_ptr; 410 if general_delete_acl.version ^= GENERAL_DELETE_ACL_VERSION_1 411 then call BAD_VERSION; 412 413 if general_delete_acl.count > 0 414 then call hcs_$delete_acl_entries (Dir_name, Entryname, addr (general_delete_acl.entries), general_delete_acl.count, 415 Code); 416 else call hcs_$delete_acl_entries (Dir_name, Entryname, addr (null_general_delete_acl_entry), 0, 417 Code); 418 419 return; 420 421 422 423 /**** 424* 425* list_directory: list the directory acl. This is just a matter of an 426* array. */ 427 428 list_directory: 429 entry (Dir_name, Entryname, Desired_version, Area_ptr, Acl_ptr, Code); 430 431 acl_ptr = null (); 432 old_acl_ptr = null (); 433 on cleanup 434 begin; 435 if old_acl_ptr ^= null () 436 then free old_acl_ptr -> directory_acl_array; 437 old_acl_ptr = null (); 438 end; 439 440 if Area_ptr = null () & Acl_ptr = null () 441 then call NULL_INPUT_PTR; 442 443 Code = 0; 444 if Acl_ptr ^= null () 445 then do; 446 acl_ptr = Acl_ptr; 447 if general_acl.version ^= GENERAL_ACL_VERSION_1 448 then call BAD_VERSION; 449 end; 450 else if Desired_version ^= GENERAL_ACL_VERSION_1 451 then call BAD_VERSION; 452 453 call AREA_SETUP; 454 455 if acl_ptr = null () 456 then call FULL_LIST_DIR_ACL; 457 else call SPECIFIC_LIST_DIR_ACL; 458 459 return; 460 461 462 463 FULL_LIST_DIR_ACL: 464 procedure; 465 466 old_acl_ptr = null (); 467 call hcs_$list_dir_acl (Dir_name, Entryname, get_system_free_area_ (), old_acl_ptr, null (), acl_count, code); 468 if code ^= 0 469 then do; 470 Code = code; 471 return; 472 end; 473 474 if acl_count = 0 475 then do; 476 Acl_ptr = null (); 477 if old_acl_ptr ^= null () 478 then free old_acl_ptr -> directory_acl_array; 479 return; 480 end; 481 482 allocate general_acl in (user_area); 483 general_acl.version = GENERAL_ACL_VERSION_1; 484 general_acl.entries (*) = old_acl_ptr -> directory_acl_array (*); 485 free old_acl_ptr -> directory_acl_array; 486 Acl_ptr = acl_ptr; 487 return; 488 end FULL_LIST_DIR_ACL; 489 490 491 492 SPECIFIC_LIST_DIR_ACL: 493 procedure; 494 495 acl_count = general_acl.count; 496 if acl_count > 0 497 then call hcs_$list_dir_acl (Dir_name, Entryname, null (), null (), addr (general_acl.entries), acl_count, Code); 498 else call hcs_$list_dir_acl (Dir_name, Entryname, null (), null (), addr (null_general_acl_entry), 0, Code); 499 500 return; 501 end SPECIFIC_LIST_DIR_ACL; 502 503 504 505 /**** 506* add_directory: adds dir entries */ 507 508 add_directory: 509 entry (Dir_name, Entryname, Acl_ptr, Code); 510 511 if Acl_ptr = null () 512 then call NULL_INPUT_PTR; 513 acl_ptr = Acl_ptr; 514 if general_acl.version ^= GENERAL_ACL_VERSION_1 515 then call BAD_VERSION; 516 517 if general_acl.count > 0 518 then call hcs_$add_dir_acl_entries (Dir_name, Entryname, addr (general_acl.entries), general_acl.count, Code); 519 else call hcs_$add_dir_acl_entries (Dir_name, Entryname, addr (null_general_acl_entry), 0, Code); 520 521 return; 522 523 524 525 /**** 526* delete_directory: deletes directory entries */ 527 528 delete_directory: 529 entry (Dir_name, Entryname, Acl_ptr, Code); 530 531 if Acl_ptr = null () 532 then call NULL_INPUT_PTR; 533 acl_ptr = Acl_ptr; 534 if general_delete_acl.version ^= GENERAL_DELETE_ACL_VERSION_1 535 then call BAD_VERSION; 536 537 if general_delete_acl.count > 0 538 then call hcs_$delete_dir_acl_entries (Dir_name, Entryname, addr (general_delete_acl.entries), 539 general_delete_acl.count, Code); 540 else call hcs_$delete_dir_acl_entries (Dir_name, Entryname, addr (null_general_delete_acl_entry), 541 0, Code); 542 543 return; 544 545 546 547 /**** 548* replace_directory: replaces directory acl. */ 549 550 replace_directory: 551 entry (Dir_name, Entryname, Acl_ptr, No_SysDaemon, Code); 552 553 acl_ptr = Acl_ptr; 554 if acl_ptr = null () 555 then do; 556 call hcs_$replace_dir_acl (Dir_name, Entryname, null (), 0, No_SysDaemon, Code); 557 return; 558 end; 559 560 if general_acl.version ^= GENERAL_ACL_VERSION_1 561 then call BAD_VERSION; 562 563 if general_acl.count > 0 564 then call hcs_$replace_dir_acl (Dir_name, Entryname, addr (general_acl.entries), general_acl.count, No_SysDaemon, 565 Code); 566 else call hcs_$replace_dir_acl (Dir_name, Entryname, addr (null_general_acl_entry), 0, No_SysDaemon, 567 Code); 568 569 return; 570 571 572 573 /**** * 574* list_dm_file: data management (file_manager_) files */ 575 576 list_dm_file: 577 entry (Dir_name, Entryname, Desired_version, Area_ptr, Acl_ptr, Code); 578 579 acl_ptr = null (); 580 old_acl_ptr = null (); 581 on cleanup 582 begin; 583 if old_acl_ptr ^= null () 584 then free old_acl_ptr -> segment_acl_array; 585 old_acl_ptr = null (); 586 end; 587 if Area_ptr = null () & Acl_ptr = null () 588 then call NULL_INPUT_PTR; 589 590 Code = 0; 591 if Acl_ptr ^= null () 592 then do; 593 acl_ptr = Acl_ptr; 594 if general_acl.version ^= GENERAL_ACL_VERSION_1 595 then call BAD_VERSION; 596 end; 597 else if Desired_version ^= GENERAL_ACL_VERSION_1 598 then call BAD_VERSION; 599 600 call AREA_SETUP; 601 602 if acl_ptr = null () 603 then call FULL_LIST_DM_ACL; 604 else call SPECIFIC_LIST_DM_ACL; 605 606 return; 607 608 609 610 FULL_LIST_DM_ACL: 611 procedure; 612 613 old_acl_ptr = null (); 614 call file_manager_$list_acl (Dir_name, Entryname, get_system_free_area_ (), old_acl_ptr, null (), acl_count, 615 code); 616 if code ^= 0 617 then do; 618 Code = code; 619 return; 620 end; 621 622 if acl_count = 0 623 then do; 624 Acl_ptr = null (); 625 if old_acl_ptr ^= null () 626 then free old_acl_ptr -> segment_acl_array; 627 return; 628 end; 629 630 631 allocate general_acl in (user_area); 632 general_acl.version = GENERAL_ACL_VERSION_1; 633 call CONVERT_OLD_XACL_LIST; 634 Acl_ptr = acl_ptr; 635 return; 636 end FULL_LIST_DM_ACL; 637 638 639 640 SPECIFIC_LIST_DM_ACL: 641 procedure; 642 643 acl_count = general_acl.count; 644 if acl_count > 0 645 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 646 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 647 648 old_acl_ptr -> segment_acl_array (*).access_name = general_acl.entries (*).access_name; 649 call file_manager_$list_acl (Dir_name, Entryname, null (), null (), old_acl_ptr, acl_count, code); 650 call CONVERT_OLD_XACL_LIST; 651 Code = code; 652 return; 653 end SPECIFIC_LIST_DM_ACL; 654 655 656 657 /**** 658* No extended entrypoints for files yet, since there is no hurry. */ 659 660 /**** 661* add_dm_file: adds dm entries */ 662 663 add_dm_file: 664 entry (Dir_name, Entryname, Acl_ptr, Code); 665 666 old_acl_ptr = null (); 667 on cleanup 668 begin; 669 if old_acl_ptr ^= null () 670 then free old_acl_ptr -> segment_acl_array; 671 old_acl_ptr = null (); 672 end; 673 Code = 0; 674 if Acl_ptr = null () 675 then call NULL_INPUT_PTR; 676 acl_ptr = Acl_ptr; 677 if general_acl.version ^= GENERAL_ACL_VERSION_1 678 then call BAD_VERSION; 679 680 acl_count = general_acl.count; 681 if acl_count > 0 682 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 683 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 684 685 old_acl_ptr -> segment_acl_array (*) = general_acl.entries (*), by name; 686 old_acl_ptr -> segment_acl_array (*).extended_mode = ""b; 687 call file_manager_$add_acl_entries (Dir_name, Entryname, old_acl_ptr, acl_count, Code); 688 689 if acl_count > 0 690 then general_acl.entries (*).status_code = old_acl_ptr -> segment_acl_array (*).status_code; 691 free old_acl_ptr -> segment_acl_array; 692 693 return; 694 695 696 697 /**** 698* delete_dm_file: deletes file entries */ 699 700 delete_dm_file: 701 entry (Dir_name, Entryname, Acl_ptr, Code); 702 703 if Acl_ptr = null () 704 then call NULL_INPUT_PTR; 705 acl_ptr = Acl_ptr; 706 if general_delete_acl.version ^= GENERAL_DELETE_ACL_VERSION_1 707 then call BAD_VERSION; 708 709 if general_acl.count > 0 710 then call file_manager_$delete_acl_entries (Dir_name, Entryname, addr (general_delete_acl.entries), 711 general_delete_acl.count, Code); 712 else call file_manager_$delete_acl_entries (Dir_name, Entryname, addr (null_general_delete_acl_entry), 713 0, Code); 714 715 return; 716 717 718 719 /**** 720* replace_dm_file: replaces file acl. */ 721 722 replace_dm_file: 723 entry (Dir_name, Entryname, Acl_ptr, No_SysDaemon, Code); 724 725 old_acl_ptr = null (); 726 on cleanup 727 begin; 728 if old_acl_ptr ^= null () 729 then free old_acl_ptr -> segment_acl_array; 730 old_acl_ptr = null (); 731 end; 732 acl_ptr = Acl_ptr; 733 Code = 0; 734 if acl_ptr = null () 735 then do; 736 call file_manager_$replace_acl (Dir_name, Entryname, null (), 0, No_SysDaemon, Code); 737 return; 738 end; 739 740 if general_acl.version ^= GENERAL_ACL_VERSION_1 741 then call BAD_VERSION; 742 743 acl_count = general_acl.count; 744 745 if acl_count > 0 746 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 747 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 748 old_acl_ptr -> segment_acl_array (*) = general_acl.entries (*), by name; 749 750 call file_manager_$replace_acl (Dir_name, Entryname, old_acl_ptr, acl_count, No_SysDaemon, Code); 751 752 if acl_count > 0 753 then general_acl.entries (*).status_code = old_acl_ptr -> segment_acl_array (*).status_code; 754 free old_acl_ptr -> segment_acl_array; 755 756 return; 757 758 759 760 /**** 761* The next group of entrypoints are for MSF_manager, 762* that has all the problems hcs_ has plus having to open the MSF. */ 763 764 list_msf: 765 entry (Dir_name, Entryname, Desired_version, Area_ptr, Acl_ptr, Code); 766 767 old_acl_ptr = null (); 768 on cleanup 769 begin; 770 if old_acl_ptr ^= null () 771 then free old_acl_ptr -> segment_acl_array; 772 old_acl_ptr = null (); 773 end; 774 775 Code = 0; 776 acl_ptr = null (); 777 if Area_ptr = null () & Acl_ptr = null () 778 then call NULL_INPUT_PTR; 779 780 if Acl_ptr ^= null () 781 then do; 782 acl_ptr = Acl_ptr; 783 if general_acl.version ^= GENERAL_ACL_VERSION_1 784 then call BAD_VERSION; 785 end; 786 else if Desired_version ^= GENERAL_ACL_VERSION_1 787 then call BAD_VERSION; 788 789 790 call AREA_SETUP; 791 792 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 793 if Code ^= 0 794 then return; 795 796 if acl_ptr = null () 797 then call FULL_LIST_MSF_ACL_CENSORED; 798 else call SPECIFIC_LIST_MSF_ACL_CENSORED; 799 800 call msf_manager_$close (MSF_fcb); 801 return; 802 803 804 805 FULL_LIST_MSF_ACL_CENSORED: 806 procedure; 807 808 call msf_manager_$acl_list (MSF_fcb, get_system_free_area_ (), old_acl_ptr, null (), acl_count, Code); 809 if Code ^= 0 810 then return; 811 if acl_count = 0 812 then do; 813 Acl_ptr = null (); 814 if old_acl_ptr ^= null () 815 then free old_acl_ptr -> segment_acl_array; 816 return; 817 end; 818 allocate general_acl in (user_area); 819 general_acl.version = GENERAL_ACL_VERSION_1; 820 call CONVERT_OLD_XACL_LIST; /* does the free, as well */ 821 Acl_ptr = acl_ptr; 822 return; 823 end FULL_LIST_MSF_ACL_CENSORED; 824 825 SPECIFIC_LIST_MSF_ACL_CENSORED: 826 procedure; 827 828 acl_count = general_acl.count; 829 if acl_count > 0 830 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 831 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 832 833 old_acl_ptr -> segment_acl_array (*).access_name = general_acl.entries (*).access_name; 834 call msf_manager_$acl_list (MSF_fcb, null (), null (), old_acl_ptr, acl_count, Code); 835 call CONVERT_OLD_XACL_LIST; 836 return; 837 end SPECIFIC_LIST_MSF_ACL_CENSORED; 838 839 840 841 /**** 842* list_msf_extended: lists extended acls of MSF acls. */ 843 844 list_msf_extended: 845 entry (Dir_name, Entryname, Desired_version, Area_ptr, Acl_ptr, Code); 846 847 acl_ptr = null (); 848 Code = 0; 849 850 old_acl_ptr = null (); 851 on cleanup 852 begin; 853 if old_acl_ptr ^= null () 854 then free old_acl_ptr -> segment_acl_array; 855 old_acl_ptr = null (); 856 end; 857 858 if Desired_version ^= GENERAL_EXTENDED_ACL_VERSION_1 & Acl_ptr = null () 859 then call BAD_VERSION; 860 861 if Acl_ptr ^= null () 862 then do; 863 acl_ptr = Acl_ptr; 864 if general_extended_acl.version ^= GENERAL_EXTENDED_ACL_VERSION_1 865 then call BAD_VERSION; 866 end; 867 868 call AREA_SETUP; 869 870 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 871 if Code ^= 0 872 then return; 873 874 if acl_ptr = null () 875 then call FULL_LIST_MSF_ACL; 876 else call SPECIFIC_LIST_MSF_ACL; 877 878 call msf_manager_$close (MSF_fcb); 879 return; 880 881 882 883 FULL_LIST_MSF_ACL: 884 procedure; 885 886 call msf_manager_$acl_list (MSF_fcb, get_system_free_area_ (), old_acl_ptr, null (), acl_count, code); 887 if code ^= 0 888 then do; 889 Code = code; 890 return; 891 end; 892 893 if acl_count = 0 894 then do; 895 Acl_ptr = null (); 896 if old_acl_ptr ^= null () 897 then free old_acl_ptr -> segment_acl_array; 898 return; 899 end; 900 901 allocate general_extended_acl in (user_area); 902 general_extended_acl.version = GENERAL_EXTENDED_ACL_VERSION_1; 903 general_extended_acl.entries (*) = old_acl_ptr -> segment_acl_array (*); 904 free old_acl_ptr -> segment_acl_array; 905 Acl_ptr = acl_ptr; 906 return; 907 end FULL_LIST_MSF_ACL; 908 909 SPECIFIC_LIST_MSF_ACL: 910 procedure; 911 912 if general_extended_acl.count > 0 913 then call msf_manager_$acl_list (MSF_fcb, null (), null (), addr (general_extended_acl.entries), 914 general_extended_acl.count, Code); 915 else call msf_manager_$acl_list (MSF_fcb, null (), null (), addr (null_general_extended_acl_entry), 916 0, Code); 917 918 return; 919 end SPECIFIC_LIST_MSF_ACL; 920 921 922 923 /**** 924* add_msf: adds entries for MSF */ 925 926 add_msf: 927 entry (Dir_name, Entryname, Acl_ptr, Code); 928 929 acl_ptr = Acl_ptr; 930 Code = 0; 931 old_acl_ptr = null (); 932 on cleanup 933 begin; 934 if old_acl_ptr ^= null () 935 then free old_acl_ptr -> segment_acl_array; 936 old_acl_ptr = null (); 937 end; 938 if acl_ptr = null () 939 then call NULL_INPUT_PTR; 940 if general_acl.version ^= GENERAL_ACL_VERSION_1 941 then call BAD_VERSION; 942 943 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 944 if Code ^= 0 945 then return; 946 947 acl_count = general_acl.count; 948 if acl_count > 0 949 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 950 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 951 952 old_acl_ptr -> segment_acl_array (*) = general_acl.entries (*), by name; 953 call msf_manager_$acl_add (MSF_fcb, old_acl_ptr, general_acl.count, Code); 954 955 call msf_manager_$close (MSF_fcb); 956 957 if acl_count > 0 958 then general_acl.entries (*).status_code = old_acl_ptr -> segment_acl_array (*).status_code; 959 free old_acl_ptr -> segment_acl_array; 960 961 return; 962 963 964 965 /**** 966* add_msf_extended: adds entries for MSF */ 967 968 add_msf_extended: 969 entry (Dir_name, Entryname, Acl_ptr, Code); 970 971 acl_ptr = Acl_ptr; 972 Code = 0; 973 old_acl_ptr = null (); 974 on cleanup 975 begin; 976 if old_acl_ptr ^= null () 977 then free old_acl_ptr -> segment_acl_array; 978 old_acl_ptr = null (); 979 end; 980 981 if acl_ptr = null () 982 then call NULL_INPUT_PTR; 983 if general_acl.version ^= GENERAL_EXTENDED_ACL_VERSION_1 984 then call BAD_VERSION; 985 986 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 987 if Code ^= 0 988 then return; 989 990 if general_extended_acl.count > 0 991 then call msf_manager_$acl_add (MSF_fcb, addr (general_extended_acl.entries), general_extended_acl.count, Code); 992 else call msf_manager_$acl_add (MSF_fcb, addr (null_general_extended_acl_entry), 0, Code); 993 994 call msf_manager_$close (MSF_fcb); 995 return; 996 997 998 999 /**** 1000* delete_msf: deletes msf acl entries */ 1001 1002 delete_msf: 1003 entry (Dir_name, Entryname, Acl_ptr, Code); 1004 1005 if Acl_ptr = null () 1006 then call NULL_INPUT_PTR; 1007 acl_ptr = Acl_ptr; 1008 if general_delete_acl.version ^= GENERAL_DELETE_ACL_VERSION_1 1009 then call BAD_VERSION; 1010 1011 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 1012 if Code ^= 0 1013 then return; 1014 1015 if general_delete_acl.count > 0 1016 then call msf_manager_$acl_delete (MSF_fcb, addr (general_delete_acl.entries), general_delete_acl.count, Code); 1017 else call msf_manager_$acl_delete (MSF_fcb, addr (null_general_delete_acl_entry), 0, Code); 1018 1019 call msf_manager_$close (MSF_fcb); 1020 return; 1021 1022 1023 1024 /**** 1025* replace_msf: replaces msf acls. */ 1026 1027 replace_msf: 1028 entry (Dir_name, Entryname, Acl_ptr, No_SysDaemon, Code); 1029 1030 1031 acl_ptr = Acl_ptr; 1032 Code = 0; 1033 old_acl_ptr = null (); 1034 on cleanup 1035 begin; 1036 if old_acl_ptr ^= null () 1037 then free old_acl_ptr -> segment_acl_array; 1038 old_acl_ptr = null (); 1039 end; 1040 if acl_ptr = null () 1041 then null_acl = "1"b; 1042 else null_acl = "0"b; 1043 1044 if ^null_acl 1045 then if general_acl.version ^= GENERAL_ACL_VERSION_1 1046 then call BAD_VERSION; 1047 1048 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 1049 if Code ^= 0 1050 then return; 1051 1052 if null_acl 1053 then 1054 MSF_REPLACE_NULL: 1055 do; 1056 call msf_manager_$acl_replace (MSF_fcb, null (), 0, No_SysDaemon, Code); 1057 call msf_manager_$close (MSF_fcb); 1058 return; 1059 end; 1060 1061 acl_count = general_acl.count; 1062 1063 if acl_count > 0 1064 then allocate segment_acl_array in (system_free_area) set (old_acl_ptr); 1065 else allocate null_segment_acl_array in (system_free_area) set (old_acl_ptr); 1066 old_acl_ptr -> segment_acl_array (*) = general_acl.entries (*), by name; 1067 call msf_manager_$acl_replace (MSF_fcb, old_acl_ptr, acl_count, No_SysDaemon, Code); 1068 if acl_count > 0 1069 then general_acl.entries (*).status_code = old_acl_ptr -> segment_acl_array (*).status_code; 1070 free old_acl_ptr -> segment_acl_array; 1071 1072 call msf_manager_$close (MSF_fcb); 1073 return; 1074 1075 1076 1077 /**** 1078* replace_msf_extended -- allows xacl replacement for MSF'S */ 1079 1080 replace_msf_extended: 1081 entry (Dir_name, Entryname, Acl_ptr, No_SysDaemon, Code); 1082 1083 1084 acl_ptr = Acl_ptr; 1085 if acl_ptr = null () 1086 then null_acl = "1"b; 1087 else null_acl = "0"b; 1088 1089 if ^null_acl 1090 then if general_extended_acl.version ^= GENERAL_EXTENDED_ACL_VERSION_1 1091 then call BAD_VERSION; 1092 1093 call msf_manager_$open (Dir_name, Entryname, MSF_fcb, Code); 1094 if Code ^= 0 1095 then return; 1096 1097 if null_acl 1098 then go to MSF_REPLACE_NULL; 1099 1100 if general_extended_acl.count > 0 1101 then call msf_manager_$acl_replace (MSF_fcb, addr (general_extended_acl.entries), general_extended_acl.count, 1102 No_SysDaemon, Code); 1103 else call msf_manager_$acl_replace (MSF_fcb, addr (null_general_extended_acl_entry), 0, 1104 No_SysDaemon, Code); 1105 1106 call msf_manager_$close (MSF_fcb); 1107 return; 1108 1109 1110 1111 CONVERT_OLD_XACL_LIST: 1112 procedure; 1113 1114 /**** 1115* This procedure assumes that there is a segment_acl_array based (old_acl_ptr) 1116* to be copied into a general_acl, and freed. */ 1117 1118 if general_acl.count > 0 1119 then general_acl.entries (*) = old_acl_ptr -> segment_acl_array (*), by name; 1120 free old_acl_ptr -> segment_acl_array; 1121 return; 1122 end CONVERT_OLD_XACL_LIST; 1123 1124 1125 1126 AREA_SETUP: 1127 procedure; 1128 1129 if Area_ptr = null () 1130 then area_ptr = get_user_free_area_ (); /* may not be used if we are listing specifically */ 1131 else area_ptr = Area_ptr; 1132 return; 1133 1134 end AREA_SETUP; 1135 1136 BAD_VERSION: 1137 procedure; 1138 2 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 2 2 /* format: style3 */ 2 3 2 4 /* These constants are to be used for the flags argument of sub_err_ */ 2 5 /* They are just "string (condition_info_header.action_flags)" */ 2 6 2 7 declare ( 2 8 ACTION_CAN_RESTART init (""b), 2 9 ACTION_CANT_RESTART init ("1"b), 2 10 ACTION_DEFAULT_RESTART 2 11 init ("01"b), 2 12 ACTION_QUIET_RESTART 2 13 init ("001"b), 2 14 ACTION_SUPPORT_SIGNAL 2 15 init ("0001"b) 2 16 ) bit (36) aligned internal static options (constant); 2 17 2 18 /* End include file */ 1139 1140 declare sub_err_ entry () options (variable); 1141 declare error_table_$unimplemented_version 1142 fixed bin (35) ext static; 1143 declare error_table_$null_info_ptr 1144 fixed bin (35) ext static; 1145 1146 /**** * 1147* file_system_ is supposed to check these version, but we signal here 1148* just in case. */ 1149 1150 call sub_err_ (error_table_$unimplemented_version, "Invalid ACL structure version", ACTION_CANT_RESTART, 1151 null (), (0), ""); 1152 1153 return; 1154 1155 NULL_INPUT_PTR: 1156 entry; 1157 1158 call sub_err_ (error_table_$null_info_ptr, "Null ACL structure pointer", ACTION_CANT_RESTART, null (), (0), ""); 1159 return; 1160 end BAD_VERSION; 1161 1162 end fs_acl_util_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/17/00 1935.8 fs_acl_util_.pl1 >udd>sm>ds>w>ml>fs_acl_util_.pl1 39 1 10/14/83 1706.6 acl_structures.incl.pl1 >ldd>incl>acl_structures.incl.pl1 1139 2 04/16/82 1058.1 sub_err_flags.incl.pl1 >ldd>incl>sub_err_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. ACTION_CANT_RESTART 000013 constant bit(36) initial dcl 2-7 set ref 1150* 1158* Acl_ptr parameter pointer dcl 34 set ref 105 119 122 124 155* 163* 190 194 232 246 249 251 281* 291* 314 318 321 334 345 353 378 382 385 402 407 409 428 440 444 446 476* 486* 508 511 513 528 531 533 550 553 576 587 591 593 624* 634* 663 674 676 700 703 705 722 732 764 777 780 782 813* 821* 844 858 861 863 895* 905* 926 929 968 971 1002 1005 1007 1027 1031 1080 1084 Area_ptr parameter pointer dcl 33 ref 105 232 428 440 576 587 764 777 844 1129 1131 Code parameter fixed bin(35,0) dcl 35 set ref 105 109* 150* 179* 190 193* 222* 232 236* 275* 300* 303* 314 317* 325* 328* 334 337* 349* 366* 378 381* 389* 392* 402 405* 413* 416* 428 443* 470* 496* 498* 508 517* 519* 528 537* 540* 550 556* 563* 566* 576 590* 618* 651* 663 673* 687* 700 709* 712* 722 733* 736* 750* 764 775* 792* 793 808* 809 834* 844 848* 870* 871 889* 912* 915* 926 930* 943* 944 953* 968 972* 986* 987 990* 992* 1002 1011* 1012 1015* 1017* 1027 1032* 1048* 1049 1056* 1067* 1080 1093* 1094 1100* 1103* Desired_version parameter char(8) dcl 36 ref 105 119 232 246 428 450 576 597 764 786 844 858 Dir_name parameter char packed unaligned dcl 31 set ref 105 147* 178* 190 217* 232 272* 300* 303* 314 325* 328* 334 349* 366* 378 389* 392* 402 413* 416* 428 467* 496* 498* 508 517* 519* 528 537* 540* 550 556* 563* 566* 576 614* 649* 663 687* 700 709* 712* 722 736* 750* 764 792* 844 870* 926 943* 968 986* 1002 1011* 1027 1048* 1080 1093* Entryname parameter char packed unaligned dcl 32 set ref 105 147* 178* 190 217* 232 272* 300* 303* 314 325* 328* 334 349* 366* 378 389* 392* 402 413* 416* 428 467* 496* 498* 508 517* 519* 528 537* 540* 550 556* 563* 566* 576 614* 649* 663 687* 700 709* 712* 722 736* 750* 764 792* 844 870* 926 943* 968 986* 1002 1011* 1027 1048* 1080 1093* GENERAL_ACL_VERSION_1 000004 constant char(8) initial packed unaligned dcl 1-72 ref 119 125 161 206 354 447 450 483 514 560 594 597 632 677 740 783 786 819 940 1044 GENERAL_DELETE_ACL_VERSION_1 000000 constant char(8) initial packed unaligned dcl 1-72 ref 410 534 706 1008 GENERAL_EXTENDED_ACL_VERSION_1 000002 constant char(8) initial packed unaligned dcl 1-72 ref 246 252 288 322 386 858 864 902 983 1089 MSF_fcb 000112 automatic pointer dcl 47 set ref 792* 800* 808* 834* 870* 878* 886* 912* 915* 943* 953* 955* 986* 990* 992* 994* 1011* 1015* 1017* 1019* 1048* 1056* 1057* 1067* 1072* 1093* 1100* 1103* 1106* No_SysDaemon parameter bit(1) packed unaligned dcl 37 set ref 334 349* 366* 378 389* 392* 550 556* 563* 566* 722 736* 750* 1027 1056* 1067* 1080 1100* 1103* access_name 3 based char(32) array level 3 in structure "general_acl" packed packed unaligned dcl 1-7 in procedure "fs_acl_util_" set ref 177 648 833 access_name based char(32) array level 2 in structure "segment_acl_array" packed packed unaligned dcl 1-46 in procedure "fs_acl_util_" set ref 177* 648* 833* acl_count 000102 automatic fixed bin(17,0) dcl 1-5 set ref 114 147* 153 156 160 160 172* 173 173 177 178* 198 210* 211 211 215 216 217* 219 219 221 241 272* 279 282 287 287 289 290 299* 300 300* 341 357* 359 359 363 364 366* 368 368 370 435 467* 474 477 482 482 484 485 495* 496 496* 583 614* 622 625 631 631 643* 644 644 648 649* 669 680* 681 681 685 686 687* 689 689 691 728 743* 745 745 748 750* 752 752 754 770 808* 811 814 818 818 828* 829 829 833 834* 853 886* 893 896 901 901 903 904 934 947* 948 948 952 957 957 959 976 1036 1061* 1063 1063 1066 1067* 1068 1068 1070 1118 1120 acl_ptr 000100 automatic pointer dcl 1-4 set ref 108* 124* 125 135 160* 161 163 172 177 194* 203 206 210 215 219 235* 251* 252 258 287* 288 289 291 299 300 300 321* 322 325 325 325 325 353* 354 357 364 368 385* 386 389 389 389 389 409* 410 413 413 413 413 431* 446* 447 455 482* 483 484 486 495 496 496 513* 514 517 517 517 517 533* 534 537 537 537 537 553* 554 560 563 563 563 563 579* 593* 594 602 631* 632 634 643 648 676* 677 680 685 689 705* 706 709 709 709 709 732* 734 740 743 748 752 776* 782* 783 796 818* 819 821 828 833 847* 863* 864 874 901* 902 903 905 912 912 912 912 929* 938 940 947 952 953 957 971* 981 983 990 990 990 990 1007* 1008 1015 1015 1015 1015 1031* 1040 1044 1061 1066 1068 1084* 1085 1089 1100 1100 1100 1100 1118 1118 area_ptr 000106 automatic pointer dcl 44 set ref 160 287 482 631 818 901 1129* 1131* cleanup 000154 stack reference condition dcl 98 ref 112 196 239 339 433 581 667 726 768 851 932 974 1034 code 000110 automatic fixed bin(35,0) dcl 46 set ref 147* 148 150 178* 179 217* 222 272* 273 275 467* 468 470 614* 616 618 649* 651 886* 887 889 count 2 based fixed bin(17,0) level 2 in structure "general_acl" dcl 1-7 in procedure "fs_acl_util_" set ref 160* 172 177 177 177 177 210 215 219 357 364 368 482* 484 495 517 517* 563 563* 631* 643 648 648 648 648 680 685 689 709 743 748 752 818* 828 833 833 833 833 947 952 953* 957 1061 1066 1068 1118 1118 count 2 based fixed bin(17,0) level 2 in structure "general_delete_acl" dcl 1-30 in procedure "fs_acl_util_" set ref 413 413* 537 537* 709* 1015 1015* count 2 based fixed bin(17,0) level 2 in structure "general_extended_acl" dcl 1-18 in procedure "fs_acl_util_" set ref 287* 289 299 325 325* 389 389* 901* 903 912 912* 990 990* 1100 1100* delete_acl_entry based structure level 1 dcl 1-63 directory_acl_array based structure array level 1 dcl 1-55 ref 435 477 484 485 directory_acl_entry based structure level 1 dcl 1-54 entries 3 based structure array level 2 in structure "general_acl" dcl 1-7 in procedure "fs_acl_util_" set ref 215 364 484* 496 496 517 517 563 563 685 748 952 1066 1118* entries 3 based structure array level 2 in structure "general_delete_acl" dcl 1-30 in procedure "fs_acl_util_" set ref 413 413 537 537 709 709 1015 1015 entries 3 based structure array level 2 in structure "general_extended_acl" dcl 1-18 in procedure "fs_acl_util_" set ref 289* 300 300 325 325 389 389 903* 912 912 990 990 1100 1100 error_table_$null_info_ptr 000064 external static fixed bin(35,0) dcl 1143 set ref 1158* error_table_$unimplemented_version 000062 external static fixed bin(35,0) dcl 1141 set ref 1150* extended_mode 11 based bit(36) array level 2 dcl 1-46 set ref 216* 363* 686* file_manager_$add_acl_entries 000030 constant entry external dcl 69 ref 687 file_manager_$delete_acl_entries 000040 constant entry external dcl 77 ref 709 712 file_manager_$list_acl 000020 constant entry external dcl 61 ref 614 649 file_manager_$replace_acl 000050 constant entry external dcl 86 ref 736 750 general_acl based structure level 1 dcl 1-7 set ref 160 482 631 818 general_acl_entry based structure level 1 unaligned dcl 1-12 general_delete_acl based structure level 1 dcl 1-30 general_delete_acl_entry based structure level 1 dcl 1-35 general_extended_acl based structure level 1 dcl 1-18 set ref 287 901 general_extended_acl_entry based structure level 1 dcl 1-23 get_system_free_area_ 000010 constant entry external dcl 58 ref 147 147 173 175 211 213 272 272 359 361 467 467 614 614 644 646 681 683 745 747 808 808 829 831 886 886 948 950 1063 1065 get_user_free_area_ 000012 constant entry external dcl 59 ref 1129 hcs_$add_acl_entries 000024 constant entry external dcl 69 ref 217 325 328 hcs_$add_dir_acl_entries 000026 constant entry external dcl 69 ref 517 519 hcs_$delete_acl_entries 000034 constant entry external dcl 77 ref 413 416 hcs_$delete_dir_acl_entries 000036 constant entry external dcl 77 ref 537 540 hcs_$list_acl 000014 constant entry external dcl 61 ref 147 178 272 300 303 hcs_$list_dir_acl 000016 constant entry external dcl 61 ref 467 496 498 hcs_$replace_acl 000044 constant entry external dcl 86 ref 349 366 389 392 hcs_$replace_dir_acl 000046 constant entry external dcl 86 ref 556 563 566 msf_manager_$acl_add 000032 constant entry external dcl 75 ref 953 990 992 msf_manager_$acl_delete 000042 constant entry external dcl 83 ref 1015 1017 msf_manager_$acl_list 000022 constant entry external dcl 67 ref 808 834 886 912 915 msf_manager_$acl_replace 000052 constant entry external dcl 92 ref 1056 1067 1100 1103 msf_manager_$close 000056 constant entry external dcl 96 ref 800 878 955 994 1019 1057 1072 1106 msf_manager_$open 000054 constant entry external dcl 95 ref 792 870 943 986 1011 1048 1093 null_acl 000114 automatic bit(1) dcl 48 set ref 1040* 1042* 1044 1052 1085* 1087* 1089 1097 null_general_acl_entry 000115 automatic structure array level 1 dcl 51 set ref 498 498 519 519 566 566 null_general_delete_acl_entry 000127 automatic structure array level 1 dcl 53 set ref 416 416 540 540 712 712 1017 1017 null_general_extended_acl_entry 000140 automatic structure array level 1 dcl 55 set ref 303 303 328 328 392 392 915 915 992 992 1103 1103 null_segment_acl_array based structure array level 1 dcl 49 ref 175 213 361 646 683 747 831 950 1065 old_acl_ptr 000104 automatic pointer dcl 42 set ref 111* 114 114 116* 146* 147* 156 156 173* 175* 177 178* 195* 198 198 200* 211* 213* 215 216 217* 219 221 238* 241 241 243* 272* 282 282 289 290 338* 341 341 343* 359* 361* 363 364 366* 368 370 432* 435 435 437* 466* 467* 477 477 484 485 580* 583 583 585* 613* 614* 625 625 644* 646* 648 649* 666* 669 669 671* 681* 683* 685 686 687* 689 691 725* 728 728 730* 745* 747* 748 750* 752 754 767* 770 770 772* 808* 814 814 829* 831* 833 834* 850* 853 853 855* 886* 896 896 903 904 931* 934 934 936* 948* 950* 952 953* 957 959 973* 976 976 978* 1033* 1036 1036 1038* 1063* 1065* 1066 1067* 1068 1070 1118 1120 segment_acl_array based structure array level 1 dcl 1-46 set ref 114 156 173 198 211 215* 221 241 282 289 290 341 359 364* 370 583 625 644 669 681 685* 691 728 745 748* 754 770 814 829 853 896 903 904 934 948 952* 959 976 1036 1063 1066* 1070 1118 1120 segment_acl_entry based structure level 1 dcl 1-45 status_code 12 based fixed bin(35,0) array level 2 in structure "segment_acl_array" dcl 1-46 in procedure "fs_acl_util_" set ref 219 368 689 752 957 1068 status_code 14 based fixed bin(35,0) array level 3 in structure "general_acl" dcl 1-7 in procedure "fs_acl_util_" set ref 219* 368* 689* 752* 957* 1068* sub_err_ 000060 constant entry external dcl 1140 ref 1150 1158 system_free_area based area(1024) dcl 43 ref 173 175 211 213 359 361 644 646 681 683 745 747 829 831 948 950 1063 1065 user_area based area(1024) dcl 45 ref 160 287 482 631 818 901 version based char(8) level 2 in structure "general_acl" dcl 1-7 in procedure "fs_acl_util_" set ref 125 161* 206 354 447 483* 514 560 594 632* 677 740 783 819* 940 983 1044 version based char(8) level 2 in structure "general_delete_acl" dcl 1-30 in procedure "fs_acl_util_" ref 410 534 706 1008 version based char(8) level 2 in structure "general_extended_acl" dcl 1-18 in procedure "fs_acl_util_" set ref 252 288* 322 386 864 902* 1089 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 1-77 ACTION_CAN_RESTART internal static bit(36) initial dcl 2-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 2-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 2-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 2-7 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 SEG_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 1-67 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 segment_acl based structure level 1 dcl 1-40 NAMES DECLARED BY EXPLICIT CONTEXT. AREA_SETUP 010113 constant entry internal dcl 1126 ref 129 256 453 600 790 868 BAD_VERSION 010135 constant entry internal dcl 1136 ref 119 125 206 246 252 322 354 386 410 447 450 514 534 560 594 597 677 706 740 783 786 858 864 940 983 1008 1044 1089 CONVERT_OLD_XACL_LIST 010042 constant entry internal dcl 1111 ref 162 180 633 650 820 835 FULL_LIST_DIR_ACL 006547 constant entry internal dcl 463 ref 455 FULL_LIST_DM_ACL 007051 constant entry internal dcl 610 ref 602 FULL_LIST_MSF_ACL 007621 constant entry internal dcl 883 ref 874 FULL_LIST_MSF_ACL_CENSORED 007357 constant entry internal dcl 805 ref 796 FULL_LIST_SEG_ACL 006245 constant entry internal dcl 266 ref 258 FULL_LIST_SEG_ACL_CENSORED 005736 constant entry internal dcl 143 ref 135 MSF_REPLACE_NULL 005332 constant label dcl 1052 ref 1097 NULL_INPUT_PTR 010202 constant entry internal dcl 1155 ref 203 318 407 440 511 531 587 674 703 777 938 981 1005 REPLACE_NULL_SEGMENT 001077 constant label dcl 345 ref 382 SPECIFIC_LIST_DIR_ACL 006725 constant entry internal dcl 492 ref 457 SPECIFIC_LIST_DM_ACL 007166 constant entry internal dcl 640 ref 604 SPECIFIC_LIST_MSF_ACL 007757 constant entry internal dcl 909 ref 876 SPECIFIC_LIST_MSF_ACL_CENSORED 007451 constant entry internal dcl 825 ref 798 SPECIFIC_LIST_SEG_ACL 006423 constant entry internal dcl 296 ref 260 SPECIFIC_LIST_SEG_ACL_CENSORED 006053 constant entry internal dcl 169 ref 137 add_directory 002036 constant entry external dcl 508 add_dm_file 002717 constant entry external dcl 663 add_msf 004303 constant entry external dcl 926 add_msf_extended 004616 constant entry external dcl 968 add_segment 000211 constant entry external dcl 190 add_segment_extended 000642 constant entry external dcl 314 delete_directory 002202 constant entry external dcl 528 delete_dm_file 003222 constant entry external dcl 700 delete_msf 005023 constant entry external dcl 1002 delete_segment 001536 constant entry external dcl 402 fs_acl_util_ 000046 constant entry external dcl 18 list_directory 001703 constant entry external dcl 428 list_dm_file 002564 constant entry external dcl 576 list_msf 003724 constant entry external dcl 764 list_msf_extended 004117 constant entry external dcl 844 list_segment 000062 constant entry external dcl 105 list_segment_extended 000516 constant entry external dcl 232 replace_directory 002346 constant entry external dcl 550 replace_dm_file 003366 constant entry external dcl 722 replace_msf 005173 constant entry external dcl 1027 replace_msf_extended 005553 constant entry external dcl 1080 replace_segment 001012 constant entry external dcl 334 replace_segment_extended 001362 constant entry external dcl 378 NAMES DECLARED BY CONTEXT OR IMPLICATION. addr builtin function ref 300 300 303 303 325 325 328 328 389 389 392 392 413 413 416 416 496 496 498 498 517 517 519 519 537 537 540 540 563 563 566 566 709 709 712 712 912 912 915 915 990 990 992 992 1015 1015 1017 1017 1100 1100 1103 1103 null builtin function ref 108 111 114 116 119 122 135 146 147 147 155 156 178 178 178 178 195 198 200 203 235 238 241 243 246 249 258 272 272 281 282 300 300 300 300 303 303 303 303 318 338 341 343 345 349 349 382 407 431 432 435 437 440 440 444 455 466 467 467 476 477 496 496 496 496 498 498 498 498 511 531 554 556 556 579 580 583 585 587 587 591 602 613 614 614 624 625 649 649 649 649 666 669 671 674 703 725 728 730 734 736 736 767 770 772 776 777 777 780 796 808 808 813 814 834 834 834 834 847 850 853 855 858 861 874 886 886 895 896 912 912 912 912 915 915 915 915 931 934 936 938 973 976 978 981 1005 1033 1036 1038 1040 1056 1056 1085 1129 1150 1150 1158 1158 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11106 11174 10247 11116 Length 11562 10247 66 352 637 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fs_acl_util_ 728 external procedure is an external procedure. on unit on line 112 64 on unit FULL_LIST_SEG_ACL_CENSORED internal procedure shares stack frame of external procedure fs_acl_util_. SPECIFIC_LIST_SEG_ACL_CENSORED internal procedure shares stack frame of external procedure fs_acl_util_. on unit on line 196 64 on unit on unit on line 239 64 on unit FULL_LIST_SEG_ACL internal procedure shares stack frame of external procedure fs_acl_util_. SPECIFIC_LIST_SEG_ACL internal procedure shares stack frame of external procedure fs_acl_util_. on unit on line 339 64 on unit on unit on line 433 64 on unit FULL_LIST_DIR_ACL internal procedure shares stack frame of external procedure fs_acl_util_. SPECIFIC_LIST_DIR_ACL internal procedure shares stack frame of external procedure fs_acl_util_. on unit on line 581 64 on unit FULL_LIST_DM_ACL internal procedure shares stack frame of external procedure fs_acl_util_. SPECIFIC_LIST_DM_ACL internal procedure shares stack frame of external procedure fs_acl_util_. on unit on line 667 64 on unit on unit on line 726 64 on unit on unit on line 768 64 on unit FULL_LIST_MSF_ACL_CENSORED internal procedure shares stack frame of external procedure fs_acl_util_. SPECIFIC_LIST_MSF_ACL_CENSORED internal procedure shares stack frame of external procedure fs_acl_util_. on unit on line 851 64 on unit FULL_LIST_MSF_ACL internal procedure shares stack frame of external procedure fs_acl_util_. SPECIFIC_LIST_MSF_ACL internal procedure shares stack frame of external procedure fs_acl_util_. on unit on line 932 64 on unit on unit on line 974 64 on unit on unit on line 1034 64 on unit CONVERT_OLD_XACL_LIST internal procedure shares stack frame of external procedure fs_acl_util_. AREA_SETUP internal procedure shares stack frame of external procedure fs_acl_util_. BAD_VERSION internal procedure shares stack frame of external procedure fs_acl_util_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME fs_acl_util_ 000100 acl_ptr fs_acl_util_ 000102 acl_count fs_acl_util_ 000104 old_acl_ptr fs_acl_util_ 000106 area_ptr fs_acl_util_ 000110 code fs_acl_util_ 000112 MSF_fcb fs_acl_util_ 000114 null_acl fs_acl_util_ 000115 null_general_acl_entry fs_acl_util_ 000127 null_general_delete_acl_entry fs_acl_util_ 000140 null_general_extended_acl_entry fs_acl_util_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_temp call_ext_out_desc call_ext_out return_mac bound_ck_signal enable_op shorten_stack ext_entry ext_entry_desc int_entry op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. file_manager_$add_acl_entries file_manager_$delete_acl_entries file_manager_$list_acl file_manager_$replace_acl get_system_free_area_ get_user_free_area_ hcs_$add_acl_entries hcs_$add_dir_acl_entries hcs_$delete_acl_entries hcs_$delete_dir_acl_entries hcs_$list_acl hcs_$list_dir_acl hcs_$replace_acl hcs_$replace_dir_acl msf_manager_$acl_add msf_manager_$acl_delete msf_manager_$acl_list msf_manager_$acl_replace msf_manager_$close msf_manager_$open sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$null_info_ptr error_table_$unimplemented_version LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000045 105 000053 108 000107 109 000111 111 000112 112 000113 114 000127 116 000140 117 000143 119 000144 122 000157 124 000163 125 000166 129 000173 135 000174 137 000202 139 000203 190 000204 193 000236 194 000237 195 000242 196 000244 198 000260 200 000271 201 000274 203 000275 206 000302 210 000310 211 000313 213 000332 215 000346 216 000406 217 000420 219 000453 221 000505 222 000511 223 000513 232 000514 235 000543 236 000545 238 000546 239 000547 241 000563 243 000574 244 000577 246 000600 249 000613 251 000617 252 000622 256 000627 258 000630 260 000636 262 000637 314 000640 317 000667 318 000670 321 000675 322 000700 325 000705 328 000746 330 001004 334 001005 337 001037 338 001040 339 001042 341 001056 343 001067 344 001072 345 001073 349 001077 350 001141 353 001142 354 001145 357 001152 359 001155 361 001174 363 001210 364 001222 366 001262 368 001321 370 001353 371 001357 378 001360 381 001407 382 001410 385 001414 386 001417 389 001424 392 001471 395 001533 402 001534 405 001563 407 001564 409 001571 410 001574 413 001601 416 001642 419 001700 428 001701 431 001730 432 001732 433 001733 435 001747 437 001760 438 001763 440 001764 443 001776 444 001777 446 002003 447 002006 449 002013 450 002014 453 002023 455 002024 457 002032 459 002033 508 002034 511 002063 513 002070 514 002073 517 002100 519 002141 521 002177 528 002200 531 002227 533 002234 534 002237 537 002244 540 002305 543 002343 550 002344 553 002373 554 002376 556 002402 557 002444 560 002445 563 002452 566 002517 569 002561 576 002562 579 002611 580 002613 581 002614 583 002630 585 002641 586 002644 587 002645 590 002657 591 002660 593 002664 594 002667 596 002674 597 002675 600 002704 602 002705 604 002713 606 002714 663 002715 666 002744 667 002746 669 002762 671 002773 672 002776 673 002777 674 003000 676 003005 677 003010 680 003015 681 003020 683 003037 685 003053 686 003114 687 003126 689 003161 691 003213 693 003217 700 003220 703 003247 705 003254 706 003257 709 003264 712 003325 715 003363 722 003364 725 003413 726 003415 728 003431 730 003442 731 003445 732 003446 733 003451 734 003452 736 003456 737 003520 740 003521 743 003526 745 003531 747 003550 748 003564 750 003624 752 003663 754 003715 756 003721 764 003722 767 003751 768 003753 770 003767 772 004000 773 004003 775 004004 776 004005 777 004007 780 004020 782 004024 783 004027 785 004034 786 004035 790 004044 792 004045 793 004074 796 004076 798 004104 800 004105 801 004114 844 004115 847 004144 848 004146 850 004147 851 004150 853 004164 855 004175 856 004200 858 004201 861 004214 863 004220 864 004223 868 004230 870 004231 871 004260 874 004262 876 004270 878 004271 879 004300 926 004301 929 004330 930 004333 931 004334 932 004336 934 004352 936 004363 937 004366 938 004367 940 004374 943 004402 944 004431 947 004433 948 004436 950 004455 952 004471 953 004532 955 004547 957 004556 959 004607 961 004613 968 004614 971 004643 972 004646 973 004647 974 004651 976 004665 978 004676 979 004701 981 004702 983 004707 986 004715 987 004744 990 004746 992 004771 994 005011 995 005020 1002 005021 1005 005050 1007 005055 1008 005060 1011 005065 1012 005114 1015 005116 1017 005141 1019 005161 1020 005170 1027 005171 1031 005220 1032 005223 1033 005224 1034 005226 1036 005242 1038 005253 1039 005256 1040 005257 1042 005266 1044 005267 1048 005277 1049 005326 1052 005330 1056 005332 1057 005355 1058 005364 1061 005365 1063 005370 1065 005407 1066 005423 1067 005464 1068 005504 1070 005535 1072 005541 1073 005550 1080 005551 1084 005600 1085 005603 1087 005612 1089 005613 1093 005622 1094 005651 1097 005653 1100 005655 1103 005703 1106 005726 1107 005735 143 005736 146 005737 147 005741 148 006013 150 006015 151 006016 153 006017 155 006021 156 006023 158 006032 160 006033 161 006044 162 006047 163 006050 164 006052 169 006053 172 006054 173 006057 175 006076 177 006112 178 006174 179 006241 180 006243 181 006244 266 006245 272 006246 273 006320 275 006322 276 006323 279 006324 281 006326 282 006330 284 006337 287 006340 288 006351 289 006354 290 006414 291 006420 292 006422 296 006423 299 006424 300 006427 303 006477 306 006546 463 006547 466 006550 467 006552 468 006624 470 006626 471 006627 474 006630 476 006632 477 006634 479 006643 482 006644 483 006655 484 006660 485 006716 486 006722 487 006724 492 006725 495 006726 496 006731 498 007001 500 007050 610 007051 613 007052 614 007054 616 007126 618 007130 619 007131 622 007132 624 007134 625 007136 627 007145 631 007146 632 007157 633 007162 634 007163 635 007165 640 007166 643 007167 644 007172 646 007211 648 007225 649 007306 650 007353 651 007354 652 007356 805 007357 808 007360 809 007412 811 007415 813 007417 814 007421 816 007430 818 007431 819 007442 820 007445 821 007446 822 007450 825 007451 828 007452 829 007455 831 007474 833 007510 834 007572 835 007617 836 007620 883 007621 886 007622 887 007654 889 007656 890 007657 893 007660 895 007662 896 007664 898 007673 901 007674 902 007705 903 007710 904 007750 905 007754 906 007756 909 007757 912 007760 915 010012 918 010041 1111 010042 1118 010043 1120 010106 1121 010112 1126 010113 1129 010114 1131 010131 1132 010134 1136 010135 1150 010136 1153 010201 1155 010202 1158 010203 1159 010246 ----------------------------------------------------------- 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