COMPILATION LISTING OF SEGMENT dial_manager_call Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-17_1930.69_Mon_mdt 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 /* format: style4 */ 11 12 /* DIAL_MANAGER_CALL - Command interface to dial_manager_ */ 13 14 /* Written February 1979 by Larry Johnson */ 15 /* Modified December 1980 by E. N. Kittlitz for V2 dial_manager_arg, new dial_manager functions */ 16 /* Modified 84-04-12 BIM for access_class */ 17 18 dial_manager_call: procedure options (variable); 19 20 /* Automatic */ 21 22 dcl code fixed bin (35); 23 dcl save_code fixed bin (35); 24 dcl arg_ptr ptr; 25 dcl arg_len fixed bin; 26 dcl entry entry (ptr, fixed bin (35)) variable; 27 dcl next_arg fixed bin; 28 dcl arg_count fixed bin; 29 30 dcl io_module char (32); 31 dcl n_dialed fixed bin; 32 dcl channel_name char (32); 33 dcl 1 status_flags aligned, 34 2 dialed_up bit (1) unal, 35 2 hung_up bit (1) unal, 36 2 control bit (1) unal, 37 2 pad bit (33) unal; 38 39 dcl 1 auto_dial_manager_arg like dial_manager_arg aligned automatic; 40 dcl dmap ptr; 41 42 /* Based */ 43 44 dcl arg char (arg_len) based (arg_ptr); 45 46 /* Internal static */ 47 48 dcl static_channel fixed (71) int static init (0); 49 dcl static_channel_is_wait bit (1) int static; /* Current state of chanel - wait/call */ 50 dcl reporting_enabled bit (1) init ("1"b) int static; 51 52 /* Constants */ 53 54 dcl name char (17) int static options (constant) init ("dial_manager_call"); 55 56 /* External */ 57 58 dcl iox_$user_output ptr ext static; 59 60 dcl convert_authorization_$from_string entry (bit (72) aligned, char (*), fixed bin (35)); 61 dcl ioa_ entry options (variable); 62 dcl com_err_ entry options (variable); 63 dcl cu_$arg_count entry (fixed bin, fixed bin (35)); 64 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 65 dcl iox_$control entry (ptr, char (*), ptr, fixed bin (35)); 66 dcl ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)); 67 dcl ipc_$decl_ev_wait_chn entry (fixed bin (71), fixed bin (35)); 68 dcl ipc_$decl_ev_call_chn entry (fixed bin (71), entry, ptr, fixed bin, fixed bin (35)); 69 dcl timer_manager_$sleep entry (fixed bin (71), bit (2)); 70 dcl convert_ipc_code_ entry (fixed bin (35)); 71 dcl convert_dial_message_$return_io_module entry (fixed bin (71), char (*), char (*), fixed bin, 72 1 aligned like status_flags, fixed bin (35)); 73 74 dcl (dial_manager_$allow_dials, 75 dial_manager_$registered_server, 76 dial_manager_$dial_out, 77 dial_manager_$release_channel, 78 dial_manager_$release_channel_no_hangup, 79 dial_manager_$release_channel_no_listen, 80 dial_manager_$release_dial_id, 81 dial_manager_$shutoff_dials, 82 dial_manager_$privileged_attach, 83 dial_manager_$tandd_attach, 84 dial_manager_$terminate_dial_out) entry (ptr, fixed bin (35)); 85 86 dcl (addr, null) builtin; 87 88 /* Setup event channel for this program */ 89 90 if static_channel = 0 then do; 91 call ipc_$create_ev_chn (static_channel, code); 92 if code ^= 0 then do; 93 call convert_ipc_code_ (code); 94 call com_err_ (code, name, "Unable to create event channel."); 95 static_channel = 0; 96 return; 97 end; 98 else static_channel_is_wait = "1"b; 99 end; 100 101 /* Initialize dial_manager_args */ 102 103 dmap = addr (auto_dial_manager_arg); 104 dmap -> dial_manager_arg.version = dial_manager_arg_version_4; 105 dmap -> dial_manager_arg.dial_qualifier = ""; 106 dmap -> dial_manager_arg.dial_channel = static_channel; 107 dmap -> dial_manager_arg.channel_name = ""; 108 dmap -> dial_manager_arg.reservation_string = ""; 109 dmap -> dial_manager_arg.dial_out_destination = ""; 110 dmap -> dial_manager_arg.access_class = ""b; 111 dmap -> dial_manager_arg.flags = "0"b; 112 113 /* Process arguments */ 114 115 call cu_$arg_count (arg_count, code); 116 if code ^= 0 then do; 117 call com_err_ (code, "dial_manager_call"); 118 return; 119 end; 120 121 next_arg = 1; 122 call get_arg ("Usage: dial_manager_call request qualifier/channel"); 123 124 if arg = "allow_dials" | arg = "ad" then do; 125 call get_qualifier; 126 entry = dial_manager_$allow_dials; 127 end; 128 else if arg = "registered_server" | arg = "rs" then do; 129 call get_qualifier; 130 entry = dial_manager_$registered_server; 131 end; 132 else if arg = "dial_out" | arg = "do" then do; 133 call get_channel; 134 call get_dial_out_destination; 135 if next_arg <= arg_count then call get_reservation_string; 136 if next_arg <= arg_count then call get_access_class; 137 entry = dial_manager_$dial_out; 138 end; 139 else if arg = "release_channel" | arg = "rc" then do; 140 call get_channel; 141 entry = dial_manager_$release_channel; 142 end; 143 else if arg = "release_channel_no_hangup" | arg = "rcnh" then do; 144 call get_channel; 145 entry = dial_manager_$release_channel_no_hangup; 146 end; 147 else if arg = "release_channel_no_listen" | arg = "rcnl" then do; 148 call get_channel; 149 entry = dial_manager_$release_channel_no_listen; 150 end; 151 else if arg = "shutoff_dials" | arg = "sd" then do; 152 call get_qualifier; 153 entry = dial_manager_$shutoff_dials; 154 end; 155 else if arg = "privileged_attach" | arg = "pa" then do; 156 call get_channel; 157 entry = dial_manager_$privileged_attach; 158 end; 159 else if arg = "tandd_attach" | arg = "tda" then do; 160 call get_channel; 161 entry = dial_manager_$tandd_attach; 162 end; 163 else if arg = "terminate_dial_out" | arg = "tdo" then do; 164 call get_channel; 165 entry = dial_manager_$terminate_dial_out; 166 end; 167 else if arg = "release_dial_id" | arg = "rdi" then do; 168 call get_qualifier; 169 entry = dial_manager_$release_dial_id; 170 end; 171 else if arg = "start_report" | arg = "start" then do; 172 reporting_enabled = "1"b; 173 go to done; 174 end; 175 else if arg = "stop_report" | arg = "stop" then do; 176 reporting_enabled = "0"b; 177 go to done; 178 end; 179 else do; 180 bad_arg: call com_err_ (0, name, "Unrecognized arg: ^a", arg); 181 return; 182 end; 183 184 /* Make the dial manager call */ 185 186 if ^static_channel_is_wait then do; 187 call ipc_$decl_ev_wait_chn (static_channel, code); 188 if code ^= 0 then do; 189 call convert_ipc_code_ (code); 190 call com_err_ (code, name, "Unable to setup event wait channel."); 191 return; 192 end; 193 static_channel_is_wait = "1"b; 194 end; 195 196 call entry (dmap, save_code); /* make the call */ 197 198 call ipc_$decl_ev_call_chn (static_channel, handler, null (), 10, code); 199 if code ^= 0 then do; 200 call convert_ipc_code_ (code); 201 call com_err_ (code, name, "Unable to setup event call channel."); 202 end; 203 else static_channel_is_wait = "0"b; 204 if save_code ^= 0 then call com_err_ (save_code, name, "dial_manager_ error."); 205 206 /* Allow event calls to go off in case channel is already dialed. This is done 207* because of the way dial_manager_ uses the event channel. A subsequent 208* invocation of dial_manager_ without an intervening block will cause 209* dial_manager_ to get out of step with the event messages. */ 210 211 call timer_manager_$sleep (250000, "10"b); 212 213 done: return; 214 215 /* Handler for event call wakeups, utility procedures */ 216 217 handler: entry (arg_event_call_infop); 218 219 dcl arg_event_call_infop ptr; 220 221 if ^reporting_enabled then return; 222 event_call_info_ptr = arg_event_call_infop; 223 224 call convert_dial_message_$return_io_module (event_call_info.message, channel_name, io_module, n_dialed, 225 status_flags, code); 226 if code ^= 0 then call com_err_ (code, name, "dial_manager_ error."); 227 else do; 228 if status_flags.control then call ioa_ ("^a: Channels dialed=^d", name, n_dialed); 229 else call ioa_ ("^a: Channel ^a (^a) ^[dialed^]^[hungup^].", name, channel_name, io_module, 230 status_flags.dialed_up, status_flags.hung_up); 231 call iox_$control (iox_$user_output, "start", null (), code); 232 end; 233 return; 234 235 get_arg: proc (msg); 236 237 dcl msg char (*); 238 239 call cu_$arg_ptr (next_arg, arg_ptr, arg_len, code); 240 if code ^= 0 then do; 241 call com_err_ (code, name, "^a", msg); 242 go to done; 243 end; 244 next_arg = next_arg + 1; 245 return; 246 247 end get_arg; 248 249 get_qualifier: proc; 250 251 call get_arg ("qualifier"); 252 dmap -> dial_manager_arg.dial_qualifier = arg; 253 if next_arg <= arg_count then do; 254 call get_access_class; 255 dmap -> dial_manager_arg.privileged_operation = "1"b; 256 end; 257 return; 258 259 end get_qualifier; 260 261 get_access_class: 262 procedure; 263 call get_arg ("access class"); 264 call convert_authorization_$from_string (dmap -> dial_manager_arg.access_class, arg, code); 265 if code ^= 0 then do; 266 call com_err_ (code, name, "^a", arg); 267 go to done; 268 end; 269 dmap -> dial_manager_arg.access_class_required = "1"b; 270 end get_access_class; 271 272 get_channel: proc; 273 274 call get_arg ("channel"); 275 dmap -> dial_manager_arg.channel_name = arg; 276 return; 277 278 end get_channel; 279 280 get_dial_out_destination: proc; 281 282 call get_arg ("destination"); 283 dmap -> dial_manager_arg.dial_out_destination = arg; 284 return; 285 286 end get_dial_out_destination; 287 288 get_reservation_string: proc; 289 290 call get_arg ("reservation"); 291 dmap -> dial_manager_arg.reservation_string = arg; 292 return; 293 294 end get_reservation_string; 295 1 1 /* BEGIN INCLUDE FILE ... dial_manager_arg.incl.pl1 */ 1 2 1 3 /* Modified by E. N. Kittlitz 11/80 to add reservation string, move dial-out 1 4* destination from dial_qualifier, add dial_message. 1 5* Modified by Robert Coren 4/83 to add required access class stuff. 1 6* Modified 1984-08-27 BIM for V4, privileged_operation. 1 7**/ 1 8 1 9 1 10 dcl dial_manager_arg_version_2 fixed bin internal static initial (2) options (constant); 1 11 dcl dial_manager_arg_version_3 fixed bin internal static initial (3) options (constant); 1 12 dcl dial_manager_arg_version_4 fixed bin internal static initial (4) options (constant); 1 13 1 14 dcl 1 dial_manager_arg based aligned, 1 15 2 version fixed bin, /* = 4 */ 1 16 2 dial_qualifier char (22), /* identify different processes with same process group id */ 1 17 2 dial_channel fixed bin (71), /* event wait channel */ 1 18 2 channel_name char (32), /* channel name for privileged attach */ 1 19 /* limit of version 1 structure */ 1 20 2 dial_out_destination char (32), /* dial-out destination (e.g. phone_no) */ 1 21 2 reservation_string char (256), /* reservation string */ 1 22 2 dial_message fixed bin (71), /* OUTPUT: A.S. message received by dial_manager_ */ 1 23 /* limit of version 2 structure */ 1 24 2 access_class bit (72), /* access class to be associated with the attachment */ 1 25 2 flags aligned, 1 26 3 access_class_required bit (1) unaligned, /* indicates whether to enforce access_class */ 1 27 3 privileged_operation bit (1) unaligned, /* for accept_dials, accepts dials from */ 1 28 /* system_low:access_class */ 1 29 /* no effect on other operations yet. */ 1 30 3 mbz bit (34) unaligned; /* must be zero */ 1 31 1 32 /* END INCLUDE FILE ... dial_manager_arg.incl.pl1 */ 296 297 2 1 /* BEGIN INCLUDE FILE event_call_info.incl.pl1 */ 2 2 2 3 /* T. Casey, May 1978 */ 2 4 2 5 dcl event_call_info_ptr ptr; 2 6 2 7 dcl 1 event_call_info aligned based (event_call_info_ptr), /* argument structure passed to event call procedure */ 2 8 2 channel_id fixed bin (71), /* event channel on which wakeup occurred */ 2 9 2 message fixed bin (71), /* 72 bits of information passed by sender of wakeup */ 2 10 2 sender bit (36), /* process id of sender */ 2 11 2 origin, 2 12 3 dev_signal bit (18) unaligned, /* "1"b if device signal */ 2 13 3 ring fixed bin (17) unaligned, /* ring from which sent */ 2 14 2 data_ptr ptr; /* ptr given to dcl_event_call_channel */ 2 15 2 16 /* END INCLUDE FILE event_call_info.incl.pl1 */ 298 299 300 end dial_manager_call; 301 SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/17/00 1930.6 dial_manager_call.pl1 >udd>sm>ds>w>ml>dial_manager_call.pl1 296 1 09/13/84 1021.5 dial_manager_arg.incl.pl1 >ldd>incl>dial_manager_arg.incl.pl1 298 2 06/29/79 1828.0 event_call_info.incl.pl1 >ldd>incl>event_call_info.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. access_class 134 based bit(72) level 2 dcl 1-14 set ref 110* 264* access_class_required 136 based bit(1) level 3 packed packed unaligned dcl 1-14 set ref 269* addr builtin function dcl 86 ref 103 arg based char packed unaligned dcl 44 set ref 124 124 128 128 132 132 139 139 143 143 147 147 151 151 155 155 159 159 163 163 167 167 171 171 175 175 180* 252 264* 266* 275 283 291 arg_count 000113 automatic fixed bin(17,0) dcl 28 set ref 115* 135 136 253 arg_event_call_infop parameter pointer dcl 219 ref 217 222 arg_len 000104 automatic fixed bin(17,0) dcl 25 set ref 124 124 128 128 132 132 139 139 143 143 147 147 151 151 155 155 159 159 163 163 167 167 171 171 175 175 180 180 239* 252 264 264 266 266 275 283 291 arg_ptr 000102 automatic pointer dcl 24 set ref 124 124 128 128 132 132 139 139 143 143 147 147 151 151 155 155 159 159 163 163 167 167 171 171 175 175 180 239* 252 264 266 275 283 291 auto_dial_manager_arg 000136 automatic structure level 1 dcl 39 set ref 103 channel_name 000125 automatic char(32) packed unaligned dcl 32 in procedure "dial_manager_call" set ref 224* 229* channel_name 12 based char(32) level 2 in structure "dial_manager_arg" dcl 1-14 in procedure "dial_manager_call" set ref 107* 275* code 000100 automatic fixed bin(35,0) dcl 22 set ref 91* 92 93* 94* 115* 116 117* 187* 188 189* 190* 198* 199 200* 201* 224* 226 226* 231* 239* 240 241* 264* 265 266* com_err_ 000022 constant entry external dcl 62 ref 94 117 180 190 201 204 226 241 266 control 0(02) 000135 automatic bit(1) level 2 packed packed unaligned dcl 33 set ref 228 convert_authorization_$from_string 000016 constant entry external dcl 60 ref 264 convert_dial_message_$return_io_module 000044 constant entry external dcl 71 ref 224 convert_ipc_code_ 000042 constant entry external dcl 70 ref 93 189 200 cu_$arg_count 000024 constant entry external dcl 63 ref 115 cu_$arg_ptr 000026 constant entry external dcl 64 ref 239 dial_channel 10 based fixed bin(71,0) level 2 dcl 1-14 set ref 106* dial_manager_$allow_dials 000046 constant entry external dcl 74 ref 126 dial_manager_$dial_out 000052 constant entry external dcl 74 ref 137 dial_manager_$privileged_attach 000066 constant entry external dcl 74 ref 157 dial_manager_$registered_server 000050 constant entry external dcl 74 ref 130 dial_manager_$release_channel 000054 constant entry external dcl 74 ref 141 dial_manager_$release_channel_no_hangup 000056 constant entry external dcl 74 ref 145 dial_manager_$release_channel_no_listen 000060 constant entry external dcl 74 ref 149 dial_manager_$release_dial_id 000062 constant entry external dcl 74 ref 169 dial_manager_$shutoff_dials 000064 constant entry external dcl 74 ref 153 dial_manager_$tandd_attach 000070 constant entry external dcl 74 ref 161 dial_manager_$terminate_dial_out 000072 constant entry external dcl 74 ref 165 dial_manager_arg based structure level 1 dcl 1-14 dial_manager_arg_version_4 constant fixed bin(17,0) initial dcl 1-12 ref 104 dial_out_destination 22 based char(32) level 2 dcl 1-14 set ref 109* 283* dial_qualifier 1 based char(22) level 2 dcl 1-14 set ref 105* 252* dialed_up 000135 automatic bit(1) level 2 packed packed unaligned dcl 33 set ref 229* dmap 000276 automatic pointer dcl 40 set ref 103* 104 105 106 107 108 109 110 111 196* 252 255 264 269 275 283 291 entry 000106 automatic entry variable dcl 26 set ref 126* 130* 137* 141* 145* 149* 153* 157* 161* 165* 169* 196 event_call_info based structure level 1 dcl 2-7 event_call_info_ptr 000300 automatic pointer dcl 2-5 set ref 222* 224 flags 136 based structure level 2 dcl 1-14 set ref 111* hung_up 0(01) 000135 automatic bit(1) level 2 packed packed unaligned dcl 33 set ref 229* io_module 000114 automatic char(32) packed unaligned dcl 30 set ref 224* 229* ioa_ 000020 constant entry external dcl 61 ref 228 229 iox_$control 000030 constant entry external dcl 65 ref 231 iox_$user_output 000014 external static pointer dcl 58 set ref 231* ipc_$create_ev_chn 000032 constant entry external dcl 66 ref 91 ipc_$decl_ev_call_chn 000036 constant entry external dcl 68 ref 198 ipc_$decl_ev_wait_chn 000034 constant entry external dcl 67 ref 187 message 2 based fixed bin(71,0) level 2 dcl 2-7 set ref 224* msg parameter char packed unaligned dcl 237 set ref 235 241* n_dialed 000124 automatic fixed bin(17,0) dcl 31 set ref 224* 228* name 000000 constant char(17) initial packed unaligned dcl 54 set ref 94* 180* 190* 201* 204* 226* 228* 229* 241* 266* next_arg 000112 automatic fixed bin(17,0) dcl 27 set ref 121* 135 136 239* 244* 244 253 null builtin function dcl 86 ref 198 198 231 231 privileged_operation 136(01) based bit(1) level 3 packed packed unaligned dcl 1-14 set ref 255* reporting_enabled 000013 internal static bit(1) initial packed unaligned dcl 50 set ref 172* 176* 221 reservation_string 32 based char(256) level 2 dcl 1-14 set ref 108* 291* save_code 000101 automatic fixed bin(35,0) dcl 23 set ref 196* 204 204* static_channel 000010 internal static fixed bin(71,0) initial dcl 48 set ref 90 91* 95* 106 187* 198* static_channel_is_wait 000012 internal static bit(1) packed unaligned dcl 49 set ref 98* 186 193* 203* status_flags 000135 automatic structure level 1 dcl 33 set ref 224* timer_manager_$sleep 000040 constant entry external dcl 69 ref 211 version based fixed bin(17,0) level 2 dcl 1-14 set ref 104* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. dial_manager_arg_version_2 internal static fixed bin(17,0) initial dcl 1-10 dial_manager_arg_version_3 internal static fixed bin(17,0) initial dcl 1-11 NAMES DECLARED BY EXPLICIT CONTEXT. bad_arg 000767 constant label dcl 180 dial_manager_call 000274 constant entry external dcl 18 done 001244 constant label dcl 213 ref 173 177 242 267 get_access_class 001603 constant entry internal dcl 261 ref 136 254 get_arg 001470 constant entry internal dcl 235 ref 122 251 263 274 282 290 get_channel 001701 constant entry internal dcl 272 ref 133 140 144 148 156 160 164 get_dial_out_destination 001716 constant entry internal dcl 280 ref 134 get_qualifier 001554 constant entry internal dcl 249 ref 125 129 152 168 get_reservation_string 001736 constant entry internal dcl 288 ref 135 handler 001250 constant entry external dcl 217 ref 198 198 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2370 2464 2034 2400 Length 2746 2034 74 246 333 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME dial_manager_call 387 external procedure is an external procedure. get_arg internal procedure shares stack frame of external procedure dial_manager_call. get_qualifier internal procedure shares stack frame of external procedure dial_manager_call. get_access_class internal procedure shares stack frame of external procedure dial_manager_call. get_channel internal procedure shares stack frame of external procedure dial_manager_call. get_dial_out_destination internal procedure shares stack frame of external procedure dial_manager_call. get_reservation_string internal procedure shares stack frame of external procedure dial_manager_call. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 static_channel dial_manager_call 000012 static_channel_is_wait dial_manager_call 000013 reporting_enabled dial_manager_call STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME dial_manager_call 000100 code dial_manager_call 000101 save_code dial_manager_call 000102 arg_ptr dial_manager_call 000104 arg_len dial_manager_call 000106 entry dial_manager_call 000112 next_arg dial_manager_call 000113 arg_count dial_manager_call 000114 io_module dial_manager_call 000124 n_dialed dial_manager_call 000125 channel_name dial_manager_call 000135 status_flags dial_manager_call 000136 auto_dial_manager_arg dial_manager_call 000276 dmap dial_manager_call 000300 event_call_info_ptr dial_manager_call THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ent_var call_ext_out_desc call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ convert_authorization_$from_string convert_dial_message_$return_io_module convert_ipc_code_ cu_$arg_count cu_$arg_ptr dial_manager_$allow_dials dial_manager_$dial_out dial_manager_$privileged_attach dial_manager_$registered_server dial_manager_$release_channel dial_manager_$release_channel_no_hangup dial_manager_$release_channel_no_listen dial_manager_$release_dial_id dial_manager_$shutoff_dials dial_manager_$tandd_attach dial_manager_$terminate_dial_out ioa_ iox_$control ipc_$create_ev_chn ipc_$decl_ev_call_chn ipc_$decl_ev_wait_chn timer_manager_$sleep THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. iox_$user_output LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000273 90 000301 91 000303 92 000313 93 000315 94 000324 95 000350 96 000353 98 000354 103 000357 104 000361 105 000363 106 000366 107 000370 108 000373 109 000376 110 000401 111 000404 115 000412 116 000422 117 000424 118 000447 121 000450 122 000452 124 000460 125 000472 126 000473 127 000500 128 000501 129 000511 130 000512 131 000517 132 000520 133 000530 134 000531 135 000532 136 000536 137 000542 138 000547 139 000550 140 000560 141 000561 142 000566 143 000567 144 000577 145 000600 146 000605 147 000606 148 000616 149 000617 150 000624 151 000625 152 000635 153 000636 154 000643 155 000644 156 000654 157 000655 158 000662 159 000663 160 000673 161 000674 162 000701 163 000702 164 000712 165 000713 166 000720 167 000721 168 000731 169 000732 170 000737 171 000740 172 000750 173 000753 175 000754 176 000764 177 000766 180 000767 181 001026 186 001027 187 001031 188 001041 189 001043 190 001052 191 001076 193 001077 196 001102 198 001112 199 001141 200 001143 201 001152 202 001176 203 001177 204 001201 211 001227 213 001244 217 001245 221 001255 222 001260 224 001264 226 001317 228 001346 229 001376 231 001437 233 001467 235 001470 239 001501 240 001516 241 001520 242 001551 244 001552 245 001553 249 001554 251 001555 252 001565 253 001573 254 001576 255 001577 257 001602 261 001603 263 001604 264 001613 265 001640 266 001642 267 001674 269 001675 270 001700 272 001701 274 001702 275 001707 276 001715 280 001716 282 001717 283 001727 284 001735 288 001736 290 001737 291 001746 292 001754 ----------------------------------------------------------- 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