COMPILATION LISTING OF SEGMENT encode Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/12/82 1152.6 mst Fri Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 encode: code: proc; 12 13 /* Commands encode and decode, for enciphering and deciphering files given a key. 14* 15* Usage: 16* encode path1A {path2A ... path1N path2N} {-key STR} 17* where: 18* 1. path1A is the pathname of a segment. 19* 2. path2A is the optional pathname of the encoded result, with 20* the suffix .code assumed. The default is path1A.code. 21* 22* decode path1A {path2A ... path1N path2N} {-key STR} 23* where: 24* 1. path1A is the pathname of a segment, with .code suffix assumed. 25* 2. path2A is the optional pathname of the decoded result. 26* The default is path1A without .code suffix. 27* 28* Written 07/06/79 by Steve Herbst */ 29 /* TR7458 Add -key 10/30/80 S. Herbst */ 30 /* Fixed to check for w permission on target before asking for key 10/26/82 S. Herbst */ 31 32 33 /* Enciphered and deciphered as arrays of fixed bin (71) word pairs */ 34 dcl source_array (source_len) fixed bin (71) based (source_ptr); 35 dcl target_array (source_len) fixed bin (71) based (target_ptr); 36 37 dcl 1 entries (ecount) aligned based (eptr), /* for hcs_$star_ */ 38 2 type bit (2) unaligned, 39 2 nnames bit (16) unaligned, 40 2 nindex bit (18) unaligned; 41 42 dcl names (99 /* arbitrary */) char (32) aligned based (nptr); /* names from hcs_$star_ */ 43 44 dcl arg char (arg_len) based (arg_ptr); 45 dcl (dn, source_dn, target_dn) char (168); 46 dcl (en, equal_en, match_en, source_en, star_en, target_en) char (32); 47 dcl command char (32); /* "encode" or "decode" */ 48 dcl (buffer, buffer2) char (11); /* input key */ 49 50 dcl (encode_sw, got_key_sw, path2_sw) bit (1); 51 52 dcl error_table_$badopt fixed bin (35) ext; 53 dcl area area based (area_ptr); 54 55 dcl (area_ptr, arg_ptr, eptr, nptr, source_ptr, target_ptr) ptr; 56 57 dcl key fixed bin (71); /* encipher/decipher key */ 58 dcl bit_count fixed bin (24); 59 dcl (arg_count, ecount, i, j, source_len) fixed bin; 60 dcl arg_len fixed bin (21); 61 62 dcl code fixed bin (35); 63 dcl error_table_$badstar fixed bin (35) ext; 64 dcl error_table_$entlong fixed bin (35) ext; 65 dcl error_table_$moderr fixed bin (35) ext; 66 dcl error_table_$no_w_permission fixed bin (35) ext; 67 dcl error_table_$sameseg fixed bin (35) ext; 68 dcl error_table_$zero_length_seg fixed bin (35) ext; 69 70 dcl check_star_name_$entry entry (char (*), fixed bin (35)); 71 dcl com_err_ entry options (variable); 72 dcl com_err_$suppress_name entry options (variable); 73 dcl cu_$arg_count entry (fixed bin, fixed bin (35)); 74 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 75 dcl decipher_ entry (fixed bin (71), dim (*) fixed bin (71), dim (*) fixed bin (71), fixed bin); 76 dcl encipher_ entry (fixed bin (71), dim (*) fixed bin (71), dim (*) fixed bin (71), fixed bin); 77 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 78 dcl get_equal_name_ entry (char (*), char (*), char (32), fixed bin (35)); 79 dcl get_system_free_area_ entry returns (ptr); 80 dcl hcs_$initiate_count entry (char (*), char (*), char (*), fixed bin (24), fixed bin (2), ptr, fixed bin (35)); 81 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 82 dcl hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)); 83 dcl hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, fixed bin (35)); 84 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 85 dcl hcs_$truncate_seg entry (ptr, fixed bin (19), fixed bin (35)); 86 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 87 dcl read_password_ entry (char (*), char (*)); 88 89 dcl (divide, fixed, length, null, rtrim, substr, unspec) builtin; 90 91 dcl cleanup condition; 92 /* */ 93 encode_sw = "1"b; 94 command = "encode"; 95 go to COMMON; 96 97 decode: entry; 98 99 encode_sw = "0"b; 100 command = "decode"; 101 102 COMMON: call cu_$arg_count (arg_count, code); 103 if code ^= 0 then do; 104 call com_err_ (code, command); 105 return; 106 end; 107 if arg_count = 0 then do; 108 call com_err_$suppress_name (0, command, 109 "Usage: ^a path1A {path2A ... path1N path2N}", command); 110 return; 111 end; 112 113 got_key_sw = "0"b; 114 115 path2_sw = "0"b; 116 do i = 1 to arg_count; 117 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 118 if substr (arg, 1, 1) = "-" then 119 if arg = "-key" then do; 120 if got_key_sw then do; 121 call com_err_ (0, command, "Attempt to specify two keys."); 122 return; 123 end; 124 i = i + 1; 125 if i > arg_count then do; 126 call com_err_ (0, command, "No value specified for -key."); 127 return; 128 end; 129 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 130 if arg_len > length (buffer) then do; 131 call com_err_ (0, command, "Key longer than ^d characters.", length (buffer)); 132 return; 133 end; 134 buffer = arg; 135 136 /* Calculate fixed bin (71) key */ 137 138 call build_key (buffer, key); 139 140 arg_ptr = null; 141 got_key_sw = "1"b; 142 end; 143 else do; 144 call com_err_ (error_table_$badopt, command, "^a", arg); 145 return; 146 end; 147 end; 148 149 do i = 1 to arg_count; 150 call cu_$arg_ptr (i, arg_ptr, arg_len, code); 151 if substr (arg, 1, 1) = "-" then do; 152 i = i + 1; 153 go to END_LOOP; 154 end; 155 156 call expand_pathname_ (arg, dn, en, code); 157 if code ^= 0 then do; 158 call com_err_ (code, command, "^a", arg); 159 return; 160 end; 161 if path2_sw then do; 162 target_dn = dn; 163 equal_en = en; 164 165 call cipher_stars; 166 167 path2_sw = "0"b; 168 end; 169 else do; 170 source_dn = dn; 171 star_en = en; 172 path2_sw = "1"b; 173 end; 174 END_LOOP: 175 end; 176 if path2_sw then do; 177 target_dn = dn; 178 equal_en = "=="; 179 180 call cipher_stars; 181 end; 182 183 RETURN: return; 184 /* */ 185 cipher_stars: proc; 186 187 /* This internal procedure applies the star convention and calls cipher */ 188 189 call check_star_name_$entry (star_en, code); 190 if code = error_table_$badstar then do; 191 call com_err_ (code, command, "^a", pathname_ (source_dn, star_en)); 192 go to RETURN; 193 end; 194 else if code = 0 then do; /* no stars */ 195 source_en = star_en; 196 197 call cipher; 198 return; 199 end; 200 201 /* Starname */ 202 203 eptr, nptr = null; 204 205 on condition (cleanup) call star_clean_up; 206 207 area_ptr = get_system_free_area_ (); 208 match_en = star_en; 209 if ^encode_sw then call append_code (match_en); 210 211 call hcs_$star_ (source_dn, match_en, 3 /* all */, area_ptr, ecount, eptr, nptr, code); 212 if code ^= 0 then do; 213 call com_err_ (code, command, "^a", pathname_ (source_dn, star_en)); 214 return; 215 end; 216 217 do j = 1 to ecount; 218 source_en = names (fixed (entries (j).nindex)); 219 if ^encode_sw then /* remove .code suffix */ 220 source_en = substr (source_en, 1, length (rtrim (source_en)) - 5); 221 222 call cipher; 223 end; 224 225 call star_clean_up; 226 227 star_clean_up: proc; 228 229 if eptr ^= null then free entries in (area); 230 if nptr ^= null then free names in (area); 231 232 end star_clean_up; 233 234 end cipher_stars; 235 /* */ 236 cipher: proc; 237 238 /* This internal procedure applies the equal convention and processes a single segment */ 239 240 call get_equal_name_ (source_en, equal_en, target_en, code); 241 if code ^= 0 then do; 242 call com_err_ (code, command, "^a", equal_en); 243 return; 244 end; 245 246 if encode_sw then call append_code (target_en); 247 else call append_code (source_en); 248 249 call hcs_$initiate_count (source_dn, source_en, "", bit_count, 0, source_ptr, code); 250 if source_ptr = null then do; 251 SOURCE_ERROR: call com_err_ (code, command, "^a", pathname_ (source_dn, source_en)); 252 return; 253 end; 254 source_len = divide (bit_count + 71, 72, 18, 0); /* number of double words in segment */ 255 if source_len = 0 then do; 256 code = error_table_$zero_length_seg; 257 go to SOURCE_ERROR; 258 end; 259 call hcs_$make_seg (target_dn, target_en, "", 01010b, target_ptr, code); 260 if target_ptr = null then do; 261 TARGET_ERROR: call com_err_ (code, command, "^a", pathname_ (target_dn, target_en)); 262 return; 263 end; 264 call hcs_$truncate_seg (target_ptr, 0, code); 265 if code ^= 0 then do; 266 if code = error_table_$moderr then code = error_table_$no_w_permission; 267 go to TARGET_ERROR; 268 end; 269 270 if source_ptr = target_ptr then do; 271 code = error_table_$sameseg; 272 go to SOURCE_ERROR; 273 end; 274 275 if ^got_key_sw then do; 276 buffer, buffer2 = ""; 277 GET_KEY: call read_password_ ("Key:", buffer); 278 if encode_sw then do; 279 call read_password_ ("Verify:", buffer2); 280 if buffer ^= buffer2 then do; /* twice to make sure */ 281 call com_err_ (0, "encode", "Keys do not match. Please try again."); 282 go to GET_KEY; 283 end; 284 end; 285 286 /* Generate a fixed bin (71) key */ 287 288 call build_key (buffer, key); 289 290 buffer2 = ""; 291 got_key_sw = "1"b; 292 end; 293 294 if encode_sw then call encipher_ (key, source_array, target_array, source_len); 295 else call decipher_ (key, source_array, target_array, source_len); 296 297 call hcs_$set_bc_seg (target_ptr, bit_count, code); 298 call hcs_$terminate_noname (source_ptr, code); 299 call hcs_$terminate_noname (target_ptr, code); 300 301 end cipher; 302 /* */ 303 append_code: proc (a_en); 304 305 /* This internal procedure appends a .code suffix and checks for entlong */ 306 307 dcl a_en char (32); 308 309 if length (rtrim (a_en)) + 5 > length (a_en) then do; 310 call com_err_ (error_table_$entlong, command, "^a.code", a_en); 311 go to RETURN; 312 end; 313 314 a_en = rtrim (a_en) || ".code"; 315 316 end append_code; 317 318 build_key: proc (A_buffer, A_key); 319 320 dcl A_buffer char (11); 321 dcl A_key fixed bin (71); 322 dcl k fixed bin; 323 dcl buffer_bits bit(99) unaligned; 324 dcl key_bits bit(72) unaligned; 325 326 dcl 1 pack unaligned defined (key_bits), 327 2 bits (10) bit (7) unaligned, 328 2 pad bit (2) unaligned; 329 330 dcl 1 strip unaligned defined (buffer_bits), 331 2 c (11) unaligned, 332 3 pad bit (2) unaligned, 333 3 bits bit (7) unaligned; 334 335 unspec (buffer_bits) = unspec (A_buffer); 336 337 do k = 1 to 10; 338 pack.bits (k) = strip.c (k).bits; 339 end; 340 341 pack.pad = substr (strip.c (11).bits, 6, 2); 342 unspec (A_key) = unspec (key_bits); 343 344 A_buffer = ""; 345 346 end build_key; 347 348 end encode; 349 SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/12/82 0953.8 encode.pl1 >spec>on>11/12/82>encode.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. A_buffer parameter char(11) unaligned dcl 320 set ref 318 335 344* A_key parameter fixed bin(71,0) dcl 321 set ref 318 342* a_en parameter char(32) unaligned dcl 307 set ref 303 309 309 310* 314* 314 area based area(1024) dcl 53 ref 229 230 area_ptr 000400 automatic pointer dcl 55 set ref 207* 211* 229 230 arg based char unaligned dcl 44 set ref 118 118 134 144* 151 156* 158* arg_count 000417 automatic fixed bin(17,0) dcl 59 set ref 102* 107 116 125 149 arg_len 000424 automatic fixed bin(21,0) dcl 60 set ref 117* 118 118 129* 130 134 144 144 150* 151 156 156 158 158 arg_ptr 000402 automatic pointer dcl 55 set ref 117* 118 118 129* 134 140* 144 150* 151 156 158 bit_count 000416 automatic fixed bin(24,0) dcl 58 set ref 249* 254 297* bits 0(02) defined bit(7) array level 3 in structure "strip" packed unaligned dcl 330 in procedure "build_key" ref 338 341 bits defined bit(7) array level 2 in structure "pack" packed unaligned dcl 326 in procedure "build_key" set ref 338* buffer 000366 automatic char(11) unaligned dcl 48 set ref 130 131 131 134* 138* 276* 277* 280 288* buffer2 000371 automatic char(11) unaligned dcl 48 set ref 276* 279* 280 290* buffer_bits 000101 automatic bit(99) unaligned dcl 323 set ref 335* 338 338 341 341 c defined structure array level 2 packed unaligned dcl 330 check_star_name_$entry 000026 constant entry external dcl 70 ref 189 cleanup 000000 stack reference condition dcl 91 ref 205 code 000425 automatic fixed bin(35,0) dcl 62 set ref 102* 103 104* 117* 129* 150* 156* 157 158* 189* 190 191* 194 211* 212 213* 240* 241 242* 249* 251* 256* 259* 261* 264* 265 266 266* 271* 297* 298* 299* com_err_ 000030 constant entry external dcl 71 ref 104 121 126 131 144 158 191 213 242 251 261 281 310 com_err_$suppress_name 000032 constant entry external dcl 72 ref 108 command 000356 automatic char(32) unaligned dcl 47 set ref 94* 100* 104* 108* 108* 121* 126* 131* 144* 158* 191* 213* 242* 251* 261* 310* cu_$arg_count 000034 constant entry external dcl 73 ref 102 cu_$arg_ptr 000036 constant entry external dcl 74 ref 117 129 150 decipher_ 000040 constant entry external dcl 75 ref 295 divide builtin function dcl 89 ref 254 dn 000100 automatic char(168) unaligned dcl 45 set ref 156* 162 170 177 ecount 000420 automatic fixed bin(17,0) dcl 59 set ref 211* 217 229 en 000276 automatic char(32) unaligned dcl 46 set ref 156* 163 171 encipher_ 000042 constant entry external dcl 76 ref 294 encode_sw 000374 automatic bit(1) unaligned dcl 50 set ref 93* 99* 209 219 246 278 294 entries based structure array level 1 dcl 37 ref 229 eptr 000404 automatic pointer dcl 55 set ref 203* 211* 218 229 229 equal_en 000306 automatic char(32) unaligned dcl 46 set ref 163* 178* 240* 242* error_table_$badopt 000010 external static fixed bin(35,0) dcl 52 set ref 144* error_table_$badstar 000012 external static fixed bin(35,0) dcl 63 ref 190 error_table_$entlong 000014 external static fixed bin(35,0) dcl 64 set ref 310* error_table_$moderr 000016 external static fixed bin(35,0) dcl 65 ref 266 error_table_$no_w_permission 000020 external static fixed bin(35,0) dcl 66 ref 266 error_table_$sameseg 000022 external static fixed bin(35,0) dcl 67 ref 271 error_table_$zero_length_seg 000024 external static fixed bin(35,0) dcl 68 ref 256 expand_pathname_ 000044 constant entry external dcl 77 ref 156 fixed builtin function dcl 89 ref 218 get_equal_name_ 000046 constant entry external dcl 78 ref 240 get_system_free_area_ 000050 constant entry external dcl 79 ref 207 got_key_sw 000375 automatic bit(1) unaligned dcl 50 set ref 113* 120 141* 275 291* hcs_$initiate_count 000052 constant entry external dcl 80 ref 249 hcs_$make_seg 000054 constant entry external dcl 81 ref 259 hcs_$set_bc_seg 000056 constant entry external dcl 82 ref 297 hcs_$star_ 000060 constant entry external dcl 83 ref 211 hcs_$terminate_noname 000062 constant entry external dcl 84 ref 298 299 hcs_$truncate_seg 000064 constant entry external dcl 85 ref 264 i 000421 automatic fixed bin(17,0) dcl 59 set ref 116* 117* 124* 124 125 129* 149* 150* 152* 152* j 000422 automatic fixed bin(17,0) dcl 59 set ref 217* 218* k 000100 automatic fixed bin(17,0) dcl 322 set ref 337* 338 338* key 000414 automatic fixed bin(71,0) dcl 57 set ref 138* 288* 294* 295* key_bits 000104 automatic bit(72) unaligned dcl 324 set ref 338* 338 341* 341 342 length builtin function dcl 89 ref 130 131 131 219 309 309 match_en 000316 automatic char(32) unaligned dcl 46 set ref 208* 209* 211* names based char(32) array dcl 42 ref 218 230 nindex 0(18) based bit(18) array level 2 packed unaligned dcl 37 ref 218 nptr 000406 automatic pointer dcl 55 set ref 203* 211* 218 230 230 null builtin function dcl 89 ref 140 203 229 230 250 260 pack defined structure level 1 packed unaligned dcl 326 pad 1(34) defined bit(2) level 2 packed unaligned dcl 326 set ref 341* path2_sw 000376 automatic bit(1) unaligned dcl 50 set ref 115* 161 167* 172* 176 pathname_ 000066 constant entry external dcl 86 ref 191 191 213 213 251 251 261 261 read_password_ 000070 constant entry external dcl 87 ref 277 279 rtrim builtin function dcl 89 ref 219 309 314 source_array based fixed bin(71,0) array dcl 34 set ref 294* 295* source_dn 000152 automatic char(168) unaligned dcl 45 set ref 170* 191* 191* 211* 213* 213* 249* 251* 251* source_en 000326 automatic char(32) unaligned dcl 46 set ref 195* 218* 219* 219 219 240* 247* 249* 251* 251* source_len 000423 automatic fixed bin(17,0) dcl 59 set ref 254* 255 294 294 294* 295 295 295* source_ptr 000410 automatic pointer dcl 55 set ref 249* 250 270 294 295 298* star_en 000336 automatic char(32) unaligned dcl 46 set ref 171* 189* 191* 191* 195 208 213* 213* strip defined structure level 1 packed unaligned dcl 330 substr builtin function dcl 89 ref 118 151 219 341 target_array based fixed bin(71,0) array dcl 35 set ref 294* 295* target_dn 000224 automatic char(168) unaligned dcl 45 set ref 162* 177* 259* 261* 261* target_en 000346 automatic char(32) unaligned dcl 46 set ref 240* 246* 259* 261* 261* target_ptr 000412 automatic pointer dcl 55 set ref 259* 260 264* 270 294 295 297* 299* unspec builtin function dcl 89 set ref 335* 335 342* 342 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON 000155 constant label dcl 102 ref 95 END_LOOP 000661 constant label dcl 174 ref 153 GET_KEY 001723 constant label dcl 277 ref 282 RETURN 000677 constant label dcl 183 ref 192 311 SOURCE_ERROR 001455 constant label dcl 251 ref 257 272 TARGET_ERROR 001604 constant label dcl 261 ref 267 append_code 002217 constant entry internal dcl 303 ref 209 246 247 build_key 002311 constant entry internal dcl 318 ref 138 288 cipher 001307 constant entry internal dcl 236 ref 197 222 cipher_stars 000701 constant entry internal dcl 185 ref 165 180 code 000121 constant entry external dcl 11 decode 000144 constant entry external dcl 97 encode 000130 constant entry external dcl 11 star_clean_up 001261 constant entry internal dcl 227 ref 205 225 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2722 3014 2362 2732 Length 3242 2362 72 212 337 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME code 328 external procedure is an external procedure. cipher_stars 288 internal procedure enables or reverts conditions. on unit on line 205 64 on unit star_clean_up 64 internal procedure is called by several nonquick procedures. cipher internal procedure shares stack frame of internal procedure cipher_stars. append_code internal procedure shares stack frame of internal procedure cipher_stars. build_key 71 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME build_key 000100 k build_key 000101 buffer_bits build_key 000104 key_bits build_key code 000100 dn code 000152 source_dn code 000224 target_dn code 000276 en code 000306 equal_en code 000316 match_en code 000326 source_en code 000336 star_en code 000346 target_en code 000356 command code 000366 buffer code 000371 buffer2 code 000374 encode_sw code 000375 got_key_sw code 000376 path2_sw code 000400 area_ptr code 000402 arg_ptr code 000404 eptr code 000406 nptr code 000410 source_ptr code 000412 target_ptr code 000414 key code 000416 bit_count code 000417 arg_count code 000420 ecount code 000421 i code 000422 j code 000423 source_len code 000424 arg_len code 000425 code code THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs call_ext_out_desc call_ext_out call_int_this call_int_other return tra_ext mpfx2 enable shorten_stack ext_entry int_entry free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. check_star_name_$entry com_err_ com_err_$suppress_name cu_$arg_count cu_$arg_ptr decipher_ encipher_ expand_pathname_ get_equal_name_ get_system_free_area_ hcs_$initiate_count hcs_$make_seg hcs_$set_bc_seg hcs_$star_ hcs_$terminate_noname hcs_$truncate_seg pathname_ read_password_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt error_table_$badstar error_table_$entlong error_table_$moderr error_table_$no_w_permission error_table_$sameseg error_table_$zero_length_seg LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000120 93 000135 94 000137 95 000142 97 000143 99 000151 100 000152 102 000155 103 000166 104 000170 105 000205 107 000206 108 000210 110 000240 113 000241 115 000242 116 000243 117 000251 118 000266 120 000300 121 000302 122 000327 124 000330 125 000331 126 000334 127 000361 129 000362 130 000377 131 000402 132 000434 134 000435 138 000441 140 000451 141 000453 142 000455 144 000456 145 000510 147 000511 149 000513 150 000522 151 000537 152 000544 153 000545 156 000546 157 000576 158 000600 159 000632 161 000633 162 000635 163 000640 165 000643 167 000647 168 000650 170 000651 171 000654 172 000657 174 000661 176 000663 177 000665 178 000670 180 000673 183 000677 185 000700 189 000706 190 000723 191 000730 192 000777 194 001002 195 001004 197 001007 198 001010 203 001011 205 001014 207 001036 208 001046 209 001052 211 001062 212 001130 213 001133 214 001203 217 001204 218 001214 219 001230 222 001247 223 001250 225 001253 234 001257 227 001260 229 001266 230 001276 232 001306 236 001307 240 001310 241 001334 242 001337 243 001365 246 001366 247 001377 249 001405 250 001450 251 001455 252 001526 254 001527 255 001533 256 001534 257 001537 259 001540 260 001577 261 001604 262 001655 264 001656 265 001672 266 001675 267 001702 270 001703 271 001707 272 001712 275 001713 276 001715 277 001723 278 001743 279 001746 280 001765 281 001772 282 002021 288 002022 290 002033 291 002037 294 002041 295 002111 297 002156 298 002172 299 002204 301 002216 303 002217 309 002221 310 002240 311 002270 314 002273 316 002306 318 002310 335 002316 337 002323 338 002330 339 002337 341 002341 342 002346 344 002353 346 002357 ----------------------------------------------------------- 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