COMPILATION LISTING OF SEGMENT protocol_mpx Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0956.9 mst Sat Options: optimize map 1 /****^ ********************************************************* 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 4* * * 5* ********************************************************* */ 6 7 8 9 /****^ HISTORY COMMENTS: 10* 1) change(89-02-21,Parisek), approve(89-10-25,MECR0012), 11* audit(89-10-25,Farley), install(89-10-25,MR12.3-1100): 12* Implement protocol multiplexer. 13* END HISTORY COMMENTS */ 14 15 /* Pseudo-multiplexor implementing the interface between the MCS environment and the */ 16 /* ISO Transport level */ 17 /* C. Claveleira - CICB - 18 september 1985 */ 18 19 20 /* format: style4,delnl,insnl,^ifthendo,indattr */ 21 22 protocol_mpx: 23 proc; 24 25 /* Date Last Modified and Reason 26* 27* 28* 7 oct 1985 : C. Claveleira - Version 0.0 29* 19 oct 1985 : C. Claveleira - Version 0.1 30* 30 oct 1985 : C. Claveleira - Version 0.2 31* 05 nov 1985 : C. Claveleira - Version 0.3 32* 12 nov 1985 : C. Claveleira - Version 0.4 33* 27 nov 1985 : C. Claveleira - Version 0.5 34* 27 dec 1985 : C. Claveleira - Version 0.6 (Changes for padding x25 packets and using USER_INTERRUPT for n_con_conf) 35* 14 fev 1986 : C. Claveleira - Version 0.7 36* 14 mar 1986 : C. Claveleira - Version 0.8 37* 20 mar 1986 : C. Claveleira - Version 1.0 (multiprotocole version) 38* 02 avr 1986 : C. Claveleira - Version 1.1 (correction bug liee au timers) 39* 21 avr 1986 : C. Claveleira - Version 1.2 ( " " lors needs_space 40* 31 mai 1986 : C. Claveleira - Version 1.3 (modifs de ntd_req et ndis_req, ajout de write et read) 41* 10 jui 1986 : C. Claveleira - Version 1.4 (correction passage lastp lors appel copy_chars dans send_common) 42* 11 aou 1986 : C. Claveleira - Version 1.5 (decompte de buffers ds write/ndt_req, modif. max_chain_len et 43* check-up connections) 44* 02 sep 1986 : C. Claveleira - Version 1.6 (test taille nsdu, modif. decl. user_index, cor. bug 45* check_orphan_connections et timer) 46* 19 sep 1986 : C. Claveleira - Version 1.7 (correction bug remplissage paquets x25) 47* 26 nov 1986 : C. Claveleira - Version 1.8 (ajouts/modifs concernant le listening) 48**/ 49 50 /* PARAMETRES */ 51 dcl a_argptr ptr; 52 dcl a_data_base_ptr ptr; 53 dcl a_partial bit (1); 54 dcl a_event fixed bin (71); /* event channel name */ 55 dcl a_from_na char (15) varying; /* address of calling network */ 56 dcl a_to_na char (15) varying; /* addresse of network called */ 57 dcl a_user_index fixed bin (17); /* user index */ 58 dcl a_call_data char (48) varying; /* call data during NCON_REQ */ 59 dcl a_order char (*); 60 dcl a_scp ptr; /* pointer to buffers chain of T */ 61 dcl a_pinfop ptr; 62 dcl a_int_type fixed bin; 63 dcl a_type fixed bin; 64 dcl a_first_entry fixed bin; 65 dcl a_bytes_processed fixed bin (21); /* number of octets sent/read by ndt_req,send/read */ 66 dcl a_offset fixed bin (21); 67 dcl a_protocol_id fixed bin; /* identification of protocol */ 68 dcl a_info bit (72) aligned; 69 dcl a_code fixed bin (35); 70 71 /* VARIABLES AUTOMATIQUES */ 72 dcl from_na char (15) varying; 73 dcl to_na char (15) varying; 74 dcl user_index fixed bin (17); 75 dcl call_data char (48) varying; 76 dcl bytes_processed fixed bin (21); 77 dcl scx fixed bin; 78 dcl miip ptr; 79 dcl order char (32); 80 dcl scp ptr; /* source_chain_pointer */ 81 dcl tcp ptr; /* target_chain_ptr */ 82 dcl scl fixed bin; /* source_chain_length */ 83 dcl cscp ptr; /* current_source_chain_ptr */ 84 dcl length_to_copy fixed bin; 85 dcl sci fixed bin (21); /* source_chain_index */ 86 dcl (scidx, tidx) fixed bin; /* index into the list of user pointers */ 87 dcl (break, stop, end_chain, write_entry, read_entry) 88 bit (1); 89 dcl buf_size fixed bin; 90 dcl protocol_id fixed bin; 91 dcl orig_buf_size fixed bin; 92 dcl lchar fixed bin; 93 dcl cur_space fixed bin; 94 dcl cur_chain_len fixed bin; 95 dcl max_space fixed bin; /* maximum number of words this guy can have */ 96 dcl max_chars fixed bin; /* maximun number of character of output */ 97 dcl max_chars_in_buf fixed bin; /* number of characters in maximum-size buffer */ 98 dcl chars_in_buf fixed bin; 99 dcl (new_bufp, headp, lastp, prevp) 100 ptr; 101 dcl new_buf fixed bin; 102 dcl rest fixed bin (21); 103 dcl twx fixed bin; /* tty index */ 104 dcl code fixed bin (35); /* error code */ 105 dcl event fixed bin (71); 106 dcl cleanup condition; 107 dcl (i, m, n) fixed bin; 108 dcl devx fixed bin (17); 109 dcl locked bit (1); 110 dcl 1 CON_REQ_info aligned like NCON_REQ_info; 111 dcl 1 N_I_i aligned based (addr (buffer.chars)) like NCON_IND_info; 112 dcl 1 net_infos aligned like network_infos; 113 dcl ignore_code fixed bin (35); 114 dcl int_type fixed bin; 115 dcl inchain fixed bin (18); 116 dcl next_offset fixed bin; 117 dcl last_offset fixed bin; 118 dcl new_headp ptr; 119 dcl old_tailp ptr; 120 dcl new_first_tally fixed bin; 121 dcl old_last_tally fixed bin; 122 dcl max_tally fixed bin; 123 dcl filled bit (1); 124 dcl source_ptr ptr; 125 dcl target_ptr ptr; 126 dcl pxss_status fixed bin (35); 127 dcl process_id bit (36) aligned; 128 dcl partial bit (1); 129 130 dcl 1 CON_IND_info aligned like NCON_IND_info based (pinfop); 131 dcl 1 ndis_ind_reason aligned like NDIS_IND_REASON based (pinfop); 132 dcl new_chars char (new_first_tally) based; 133 134 135 dcl STANDARD_SERVICE char (16) int static init ("@"); 136 /* indicates DDN/X.25 standard service */ 137 dcl ever_initialized bit (1) int static init ("0"b); /* indicates whether init_multiplexer ever called before */ 138 139 140 dcl ( 141 error_table_$action_not_performed, 142 error_table_$bad_arg, 143 error_table_$buffer_big, 144 error_table_$io_no_permission, 145 error_table_$invalid_state, 146 error_table_$invalid_device, 147 error_table_$invalid_write, 148 error_table_$noalloc, 149 error_table_$resource_unavailable, 150 error_table_$undefined_order_request 151 ) ext fixed bin (35); 152 153 dcl no_write_code fixed bin (35) internal static; 154 dcl noalloc_code fixed bin (35) internal static; /* copy of code to be used at interrupt time */ 155 156 157 dcl pds$processid ext static bit (36) aligned; 158 159 dcl tty_lock$lock_channel entry (fixed bin, fixed bin (35)); 160 dcl tty_lock$unlock_channel 161 entry (fixed bin); 162 dcl pxss$ring_0_wakeup entry (bit (36) aligned, fixed bin (71), fixed bin (71), fixed bin (35)); 163 dcl pxss$unique_ring_0_wakeup 164 entry (bit (36) aligned, fixed bin (71), fixed bin (71), fixed bin (35)); 165 dcl tc_util$validate_processid 166 entry (bit (36) aligned, fixed bin (35)); 167 dcl syserr entry options (variable); 168 dcl wire_proc$wire_me entry; 169 170 dcl DIAG_71 fixed bin int static init (71) options (constant); 171 dcl LONGEST_POSSIBLE_STRING 172 fixed bin init (8128) int static options (constant); 173 dcl MILLISECONDS_2 fixed bin (21) int static init (2000000) options (constant); 174 dcl SIZE4 fixed bin int static init (4) options (constant); 175 dcl SIZE16 fixed bin int static init (16) options (constant); 176 dcl WAKEUP_CODE_0 fixed bin int static init (0) options (constant); 177 dcl WAKEUP_CODE_5 fixed bin int static init (5) options (constant); 178 dcl WAKEUP_CODE_100 fixed bin int static init (100) options (constant); 179 dcl max_chain_len fixed bin int static init (64) options (constant); 180 /* permitted to have NSDU of 4096 octets max with buffers of 124 characters (2 buffers/packet) */ 181 182 dcl (addr, bin, ceil, clock, divide, hbound, lbound, length, min, null, ptr, rel, string, substr, unspec) 183 builtin; 184 185 186 return; 187 188 start: 189 entry (a_data_base_ptr, a_code); 190 191 a_code = 0; 192 channel_ptr = a_data_base_ptr; 193 devx = channel.devx; 194 locked = "0"b; 195 channel.flags.started = "1"b; 196 if channel.state = HUNGUP 197 then call channel_manager$control (devx, "listen", null (), code); 198 a_code = code; 199 return; 200 201 202 stop: 203 entry (a_data_base_ptr, a_code); 204 channel_ptr = a_data_base_ptr; 205 channel.flags.started = "0"b; 206 a_code = 0; 207 locked = "0"b; 208 return; 209 210 211 shutdown: 212 entry (a_data_base_ptr, a_code); 213 channel_ptr = a_data_base_ptr; 214 locked = "0"b; 215 devx = channel.devx; 216 if channel.state > HUNGUP 217 then call channel_manager$control (devx, "hangup", null (), code); 218 a_code = code; 219 return; 220 221 222 priv_control: 223 entry (a_data_base_ptr, a_order, a_pinfop, a_code); 224 225 channel_ptr = a_data_base_ptr; 226 order = a_order; 227 pinfop = a_pinfop; /* nothing for time */ 228 a_code = 0; 229 locked = "0"b; 230 return; 231 232 233 hpriv_control: 234 entry (a_data_base_ptr, a_order, a_pinfop, a_code); 235 channel_ptr = a_data_base_ptr; 236 order = a_order; 237 pinfop = a_pinfop; 238 locked = "0"b; 239 devx = channel.devx; 240 if order = "load_mpx" 241 then if channel.flags.initialized & channel.state = INACTIVE 242 then do; 243 call channel_manager$control (devx, "get_network_infos", addr (net_infos), code); 244 if code = 0 245 then do; 246 channel.our_network_address = net_infos.network_address; 247 channel.max_packet_size = net_infos.max_packet_size; 248 channel.load_proc_id = pds$processid; 249 channel.state = HUNGUP; 250 end; 251 end; 252 else code = error_table_$invalid_state; 253 else code = error_table_$undefined_order_request; 254 a_code = code; 255 return; 256 257 258 init_multiplexer: /* do the work of an init_channel, in fact */ 259 entry (twx, a_argptr, a_data_base_ptr, a_code); 260 261 devx = twx; 262 infop = addr (dn355_data$); 263 protocol_data_ptr = datanet_info.protocol_datap; 264 ttybp = addr (tty_buf$); 265 lctp = tty_buf.lct_ptr; 266 lcntp = lct.lcnt_ptr; 267 miip = a_argptr; 268 a_data_base_ptr = null; 269 a_code = 0; 270 locked = "0"b; 271 272 if ^ever_initialized 273 then do; /* initialization of the data base */ 274 do i = 1 to protocol_data.max_channels; 275 unspec (protocol_data.channels (i)) = ""b; 276 protocol_data.channels (i).name = ""; 277 protocol_data.channels (i).our_network_address = ""; 278 protocol_data.channels (i).his_network_address = ""; 279 protocol_data.channels (i).call_data = ""; 280 protocol_data.channels (i).facilities = ""; 281 end; 282 protocol_data.n_channels = 0; 283 protocol_data.init_time = clock (); 284 unspec (listeners (*)) = ""b; 285 unspec (protocol_data.special_listeners (*)) = ""b; 286 protocol_data.special_listeners.datas (*) = ""; 287 call set_static; 288 ever_initialized = "1"b; 289 end; 290 291 if protocol_data.n_channels >= protocol_data.max_channels 292 then do; /* more channels declared than you have ? */ 293 call syserr (Log_message, "protocol_mpx$init_multiplexer : not enough channels configured on PROT PARM."); 294 a_code = noalloc_code; 295 return; 296 end; 297 protocol_data.n_channels = protocol_data.n_channels + 1; 298 do i = 1 to protocol_data.max_channels; 299 channel_ptr = addr (protocol_data.channels (i)); 300 if ^channel.flags.initialized 301 then do; 302 channel.name = lcnt (devx).names; 303 channel.devx = devx; 304 channel.state = INACTIVE; 305 channel.flags.initialized = "1"b; 306 a_data_base_ptr = channel_ptr; 307 return; 308 end; 309 end; 310 call syserr (Log_message, "protocol_mpx$init_multiplexer : no free channel found"); 311 a_code = noalloc_code; 312 return; 313 314 315 316 terminate_multiplexer: 317 entry (a_data_base_ptr, a_code); 318 319 a_code = 0; 320 locked = "0"b; 321 channel_ptr = a_data_base_ptr; 322 infop = addr (dn355_data$); 323 protocol_data_ptr = datanet_info.protocol_datap; 324 call mcs_timer$reset_all (channel.devx); /* purge the event timers */ 325 protocol_data.n_channels = protocol_data.n_channels - 1; 326 if protocol_data.n_channels < 0 327 then call syserr (Log_message, 328 "protocol_mpx$terminate_multiplexer : more terminate_multiplexer calls than init_multiplexer calls on ^a", 329 channel.name); 330 unspec (channel) = ""b; 331 a_data_base_ptr = null (); 332 return; 333 334 set_listener: 335 entry (a_protocol_id, a_event, a_code); 336 event = a_event; 337 protocol_id = a_protocol_id; 338 locked = "0"b; 339 infop = addr (dn355_data$); 340 protocol_data_ptr = datanet_info.protocol_datap; 341 if protocol_id < lbound (protocol_data.listeners, 1) | protocol_id > hbound (protocol_data.listeners, 1) 342 then do; 343 a_code = error_table_$bad_arg; 344 return; 345 end; /* Not test to learn if there is already a listener : use the last one. */ 346 protocol_data.listeners (protocol_id).proc_id = pds$processid; 347 protocol_data.listeners (protocol_id).event_id = event; 348 a_code = 0; 349 return; 350 351 set_special_listener: 352 entry (a_call_data, a_partial, a_event, a_code); 353 call_data = a_call_data; 354 event = a_event; 355 partial = a_partial; 356 a_code = 0; 357 locked = "0"b; 358 do i = 1 to hbound (layer3_call_datas, 1) while (call_data ^= layer3_call_datas (i)); 359 end; 360 if i <= hbound (layer3_call_datas, 1) | call_data = "" 361 then do; 362 a_code = error_table_$bad_arg; 363 return; 364 end; 365 infop = addr (dn355_data$); 366 protocol_data_ptr = datanet_info.protocol_datap; 367 n = hbound (protocol_data.special_listeners, 1); 368 do i = 1 to n while (protocol_data.special_listeners.call_datas.datas (i) ^= call_data); 369 end; 370 if i > n 371 then /* find a slot */ 372 do i = 1 to n while (protocol_data.special_listeners.call_datas.datas (i) ^= ""); 373 end; 374 if i > n 375 then do; 376 a_code = error_table_$action_not_performed; 377 return; 378 end; 379 protocol_data.special_listeners.call_datas.partial (i) = partial; 380 protocol_data.special_listeners.call_datas.datas (i) = call_data; 381 protocol_data.special_listeners.proc_id (i) = pds$processid; 382 protocol_data.special_listeners.event_id (i) = event; 383 return; 384 385 remove_listener: 386 entry (a_protocol_id, a_code); 387 protocol_id = a_protocol_id; 388 locked = "0"b; 389 infop = addr (dn355_data$); 390 protocol_data_ptr = datanet_info.protocol_datap; 391 if protocol_id < lbound (protocol_data.listeners, 1) | protocol_id > hbound (protocol_data.listeners, 1) 392 then do; 393 a_code = error_table_$bad_arg; 394 return; 395 end; 396 a_code = 0; 397 if protocol_data.listeners (protocol_id).proc_id ^= pds$processid 398 then a_code = error_table_$io_no_permission; 399 else unspec (protocol_data.listeners (protocol_id)) = ""b; 400 return; 401 402 remove_special_listener: 403 entry (a_call_data, a_code); 404 call_data = a_call_data; 405 locked = "0"b; 406 a_code = 0; 407 if call_data = "" 408 then do; 409 a_code = error_table_$bad_arg; 410 return; 411 end; 412 infop = addr (dn355_data$); 413 protocol_data_ptr = datanet_info.protocol_datap; 414 do i = 1 to hbound (protocol_data.special_listeners, 1) 415 while (protocol_data.special_listeners.call_datas (i).datas ^= call_data); 416 end; 417 if i > hbound (protocol_data.special_listeners, 1) 418 then do; 419 a_code = error_table_$action_not_performed; 420 return; 421 end; 422 if protocol_data.special_listeners (i).proc_id ^= pds$processid 423 then a_code = error_table_$io_no_permission; 424 else do; 425 protocol_data.special_listeners (i).call_datas.datas = ""; 426 protocol_data.special_listeners (i).call_datas.partial = "0"b; 427 protocol_data.special_listeners (i).proc_id = ""b; 428 protocol_data.special_listeners (i).event_id = 0; 429 end; 430 return; 431 432 433 ncon_req: /* Request a network connection - N_CON_REQ */ 434 entry (a_user_index, twx, a_event, a_from_na, a_to_na, a_call_data, a_code); 435 436 user_index = a_user_index; 437 event = a_event; 438 from_na = a_from_na; 439 to_na = a_to_na; 440 call_data = a_call_data; 441 442 ttybp = addr (tty_buf$); 443 lctp = tty_buf.lct_ptr; 444 infop = addr (dn355_data$); 445 protocol_data_ptr = datanet_info.protocol_datap; 446 call check_orphan_connections; /* clean up abandoned connections */ 447 twx = 0; 448 scx = get_channel (from_na); /* find an available channel */ 449 if scx = 0 450 then do; 451 a_code = error_table_$resource_unavailable; 452 return; 453 end; 454 channel_ptr = addr (protocol_data.channels (scx)); 455 devx = channel.devx; 456 locked = "0"b; 457 on cleanup call cleaner; 458 call tty_lock$lock_channel (devx, code); 459 if code ^= 0 460 then goto unlock; 461 locked = "1"b; 462 463 channel.user_proc_id, channel.listener_proc_id = pds$processid; 464 channel.user_event, channel.listener_event = event; 465 channel.user_ref = user_index; 466 channel.flags.in_use = "1"b; 467 channel.his_network_address = to_na; 468 channel.space_left_in_packet = channel.max_packet_size; 469 470 CON_REQ_info.mbz = 0; 471 CON_REQ_info.to_address = to_na; 472 CON_REQ_info.facilities = STANDARD_SERVICE; 473 CON_REQ_info.data = call_data; 474 call channel_manager$control (devx, "dial_out", addr (CON_REQ_info), code); 475 if code = 0 476 then channel.state = DIALING; 477 else call reset_channel; 478 twx = devx; 479 goto unlock; /* unlock and return */ 480 481 482 483 ncon_resp: /* reponse to request for an network connection - N_CON_RESP */ 484 entry (a_user_index, twx, a_event, a_code); 485 locked = "0"b; 486 on cleanup call cleaner; 487 call setup; 488 if channel.state ^= DIALING 489 then do; 490 code = error_table_$invalid_state; 491 goto unlock; 492 end; 493 channel.user_ref = a_user_index; 494 channel.user_event = a_event; 495 channel.user_proc_id = pds$processid; 496 call channel_manager$control (devx, "connect_response", null (), code); 497 if code = 0 498 then do; 499 channel.state = DIALED; 500 channel.rflag = "1"b; 501 end; 502 goto unlock; /* unlock and return */ 503 504 write: 505 entry (twx, a_pinfop, a_first_entry, a_offset, a_bytes_processed, a_code); 506 pinfop = a_pinfop; 507 scidx = a_first_entry; 508 sci = a_offset; 509 a_bytes_processed = 0; 510 locked = "0"b; 511 on cleanup call cleaner; 512 call setup; 513 if channel.state ^= DIALED 514 then goto inv_state; 515 if pinfop ^= null () 516 then if scidx < 0 | scidx > transmit_info.n_entries | sci < 0 | sci > transmit_info (scidx).size - 1 517 then goto bad_args; 518 else ; 519 else goto bad_args; 520 scl = 0; 521 do i = scidx to transmit_info.n_entries; 522 scl = scl + transmit_info (i).size; 523 end; 524 scl = scl - sci; 525 if scl <= 0 526 then goto unlock; 527 write_entry = "1"b; 528 break = "1"b; 529 goto send_common; 530 531 ndt_req: /* request to send network data - N_DATA_REQ */ 532 entry (twx, a_scp, a_offset, a_bytes_processed, a_code); 533 534 scp = a_scp; 535 sci = a_offset; 536 scl = 0; 537 a_bytes_processed = 0; 538 locked = "0"b; 539 on cleanup call cleaner; 540 call setup; 541 if channel.state ^= DIALED 542 then do; 543 inv_state: 544 code = error_table_$invalid_state; 545 goto unlock; 546 end; 547 548 if scp = null () 549 then do; 550 bad_args: 551 code = error_table_$bad_arg; 552 goto unlock; 553 end; 554 if sci < 0 | sci >= scp -> buffer.tally 555 then goto bad_args; 556 blockp = scp; 557 call check_length (break, scl); /* calculate the length of the user chain */ 558 scl = scl - sci; 559 if scl = 0 560 then goto unlock; 561 cscp = scp; 562 write_entry = "0"b; 563 send_common: 564 bytes_processed = 0; 565 if scl > channel.max_nsdu_size 566 then do; 567 code = error_table_$buffer_big; 568 goto unlock; 569 end; 570 cur_space = 0; /* calculate the space which you are able to claim */ 571 cur_chain_len = 0; 572 if channel.write_first ^= 0 573 then do; 574 blockp = ptr (ttybp, channel.write_first); 575 end_chain = "0"b; 576 do while (^end_chain); 577 cur_space = cur_space + SIZE16 * (buffer.size_code + 1); 578 cur_chain_len = cur_chain_len + 1; 579 if buffer.next = 0 580 then end_chain = "1"b; 581 else blockp = ptr (ttybp, buffer.next); 582 end; 583 end; 584 max_space = 585 min (divide (tty_buf.bleft, output_bpart, 17, 0) - cur_space, 586 (max_chain_len - cur_chain_len) * (channel.max_buf_size - 1)); 587 588 max_chars_in_buf = SIZE4 * (channel.max_buf_size - 1) - channel.buffer_pad; 589 590 if max_space <= 0 /* if unfortunately, you can do nothing else... */ 591 then do; 592 if channel.send_output 593 then call tty_space_man$needs_space (devx); 594 else channel.flags.wflag = "1"b; 595 goto unlock; 596 end; 597 max_chars = min (SIZE4 * max_space, LONGEST_POSSIBLE_STRING); 598 cur_chain_len = max_chain_len - cur_chain_len; /* prepare a breakdown of the buffers */ 599 length_to_copy = min (max_chars, scl); 600 if length_to_copy < scl 601 then break = "0"b; 602 603 if channel.write_last ^= 0 /* is there a chain in stock ? */ 604 then do; 605 lastp, blockp = ptr (ttybp, channel.write_last); 606 if buffer.tally < max_chars_in_buf & ^buffer.flags.break 607 & channel.space_left_in_packet ^= channel.max_packet_size 608 /* if yes can you use the last buffer ? */ 609 then do; 610 buf_size, orig_buf_size = SIZE16 * (buffer.size_code + 1); 611 lchar = buffer.tally; 612 stop = "0"b; 613 do while (^stop); /* should you enlarge this buffer ? */ 614 chars_in_buf = SIZE4 * (buf_size - 1) - channel.buffer_pad; 615 if lchar + length_to_copy <= chars_in_buf | chars_in_buf = max_chars_in_buf 616 | lchar + channel.space_left_in_packet <= chars_in_buf 617 then stop = "1"b; 618 else buf_size = buf_size + SIZE16; 619 end; 620 621 if buf_size ^= orig_buf_size /* find a bigger buffer */ 622 then do; 623 call tty_space_man$get_buffer (devx, buf_size, OUTPUT, new_bufp); 624 if new_bufp ^= null () 625 then do; 626 call copy_chars ((lastp), 0, (lastp -> buffer.tally), new_bufp, 0); 627 /* copy the old buffer into the new one */ 628 new_buf = bin (rel (new_bufp), 18); 629 new_bufp -> buffer.tally = lastp -> buffer.tally; 630 channel.write_last = new_buf; /* thread new buffer onto end of chain in place of old one */ 631 632 prevp = ptr (ttybp, channel.write_first); 633 /* start at head */ 634 if prevp = lastp /* is it tail also? */ 635 then channel.write_first = channel.write_last; 636 /* that's simple */ 637 else do; /* else we'll scan the chain */ 638 do prevp = prevp repeat ptr (ttybp, prevp -> buffer.next) 639 while (prevp -> buffer.next ^= bin (rel (lastp), 18) & prevp -> buffer.next ^= 0); 640 end; 641 prevp -> buffer.next = channel.write_last; 642 /* found the next-to-last one */ 643 end; 644 645 call tty_space_man$free_buffer (devx, OUTPUT, lastp); 646 lastp = new_bufp; 647 648 end; 649 else chars_in_buf = SIZE4 * (orig_buf_size - 1) - channel.buffer_pad; 650 end; 651 n = min (length_to_copy, chars_in_buf - lchar, channel.space_left_in_packet); 652 if write_entry 653 then call copy_from_user_to_us (scidx, sci, n, lastp, (lastp -> buffer.tally)); 654 else call copy_chars (cscp, sci, n, lastp, (lastp -> buffer.tally)); 655 bytes_processed = bytes_processed + n; 656 channel.space_left_in_packet = channel.space_left_in_packet - n; 657 if channel.space_left_in_packet = 0 658 then channel.space_left_in_packet = channel.max_packet_size; 659 length_to_copy = length_to_copy - n; 660 lastp -> buffer.tally = lastp -> buffer.tally + n; 661 string (lastp -> buffer.flags) = "0"b; 662 lastp -> buffer.next = 0; 663 end; 664 665 end; 666 667 do length_to_copy = length_to_copy repeat (length_to_copy - n) while (length_to_copy > 0); 668 m = min (length_to_copy, channel.space_left_in_packet); 669 if m >= max_chars_in_buf 670 then do; 671 n = max_chars_in_buf; 672 buf_size = channel.max_buf_size; 673 end; 674 else do; /* find a buffer of appropriate size */ 675 stop = "0"b; 676 buf_size = SIZE16; 677 do while (^stop); 678 chars_in_buf = SIZE4 * (buf_size - 1) - channel.buffer_pad; 679 if m <= chars_in_buf 680 then stop = "1"b; 681 else buf_size = buf_size + SIZE16; 682 end; 683 n = m; 684 end; 685 if cur_chain_len = 0 686 then new_bufp = null (); 687 else call tty_space_man$get_buffer (devx, buf_size, OUTPUT, new_bufp); 688 if new_bufp = null () 689 then goto try_to_send; 690 cur_chain_len = cur_chain_len - 1; /* update the breakdown of the buffers */ 691 if write_entry 692 then call copy_from_user_to_us (scidx, sci, n, new_bufp, 0); 693 else call copy_chars (cscp, sci, n, new_bufp, 0); 694 bytes_processed = bytes_processed + n; 695 new_bufp -> buffer.tally = n; 696 new_buf = bin (rel (new_bufp), 18); 697 channel.space_left_in_packet = channel.space_left_in_packet - n; 698 if channel.space_left_in_packet = 0 699 then channel.space_left_in_packet = channel.max_packet_size; 700 if channel.write_last = 0 701 then /* chain the new buffer */ 702 channel.write_first = new_buf; 703 else lastp -> buffer.next = new_buf; 704 channel.write_last = new_buf; 705 lastp = new_bufp; 706 new_bufp -> buffer.next = 0; 707 string (new_bufp -> buffer.flags) = "0"b; 708 end; 709 710 if break & length_to_copy = 0 711 then do; 712 lastp -> buffer.flags.break = "1"b; 713 channel.space_left_in_packet = channel.max_packet_size; 714 if write_entry 715 then scidx = 0; /* in case the caller structure should terminate with some entries with size = 0 */ 716 end; 717 718 try_to_send: 719 if channel.send_output 720 then call send_next_nsdu; 721 if write_entry & scidx ^= 0 | ^write_entry & cscp ^= null () 722 then do; /* if all of the user chain has not been sent */ 723 /* (in fact one can stop with a break (?) ) */ 724 channel.flags.wflag = "1"b; 725 if channel.flags.send_output 726 then call tty_space_man$needs_space (devx); /* if send_next_nsdu has not called channel_manager$write then you ought to reclaim the space! */ 727 end; 728 a_offset = sci; 729 a_bytes_processed = bytes_processed; 730 if write_entry 731 then a_first_entry = scidx; 732 else a_scp = cscp; 733 goto unlock; 734 735 736 ndis_req: /* request for a network disconnection - N_DIS_REQ */ 737 entry (twx, a_pinfop, a_code); 738 locked = "0"b; 739 on cleanup call cleaner; 740 call setup; 741 if channel.state > HUNGUP 742 then do; 743 call channel_manager$control (devx, "hangup", a_pinfop, code); 744 channel.state = HUNGUP; 745 call reset_channel; 746 end; 747 else code = error_table_$invalid_state; 748 goto unlock; /* unlock and return */ 749 750 read: 751 entry (twx, a_pinfop, rest, a_bytes_processed, a_code); 752 read_entry = "1"b; 753 int_type = NDTIND; 754 goto g_i; 755 756 get_info: /* this entrypoint is called by the user before each wakeup */ 757 entry (twx, a_int_type, a_pinfop, rest, a_bytes_processed, a_code); 758 759 int_type = a_int_type; 760 read_entry = "0"b; 761 g_i: 762 pinfop = a_pinfop; 763 rest, bytes_processed, a_bytes_processed = 0; 764 locked = "0"b; 765 on cleanup call cleaner; 766 call setup; 767 768 if int_type = NCONIND /* request for info in an N_CON_IND */ 769 then do; 770 if channel.state >= DIALING 771 then do; 772 CON_IND_info.our_address = channel.our_network_address; 773 CON_IND_info.his_address = channel.his_network_address; 774 CON_IND_info.data = channel.call_data; 775 CON_IND_info.facilities = channel.facilities; 776 CON_IND_info.dial_info = ""b; 777 rest = channel.max_nsdu_size; 778 code = 0; 779 end; 780 else code = error_table_$invalid_state; 781 end; 782 783 else if int_type = NCONCONF 784 then rest = channel.max_nsdu_size; 785 786 else if int_type = NDTIND /* recuperation of data. */ 787 then do; 788 if channel.state = DIALED 789 then do; 790 if ^read_entry 791 then do; 792 tcp = pinfop; 793 if tcp = null () 794 then goto bad_args; 795 n, i = 0; /* calculate available space in the user chain */ 796 do blockp = tcp repeat (ptr (blockp, buffer.next)) while (rel (blockp) ^= "0"b); 797 i = i + 1; /* safeguard if the user chain is munged ! */ 798 if i > 512 799 then goto bad_args; 800 n = n + max_buffer_tally (buffer.size_code); 801 end; 802 end; 803 else do; 804 if pinfop = null () 805 then goto bad_args; 806 n = 0; 807 do i = 1 to transmit_info.n_entries; 808 n = n + transmit_info (i).size; 809 if transmit_info (i).data_ptr = null () 810 then goto bad_args; 811 end; 812 tidx = 1; 813 end; 814 headp, cscp, blockp = ptr (ttybp, channel.fblock); 815 if channel.fblock ^= 0 /* you can't give what you don't have ! */ 816 then do; 817 call check_length (break, length_to_copy); 818 if ^break 819 then goto check_rest; /* if there is not a complete NSDU... */ 820 if length_to_copy > n /* if you can't go at all (pass it all ?)... */ 821 then do; 822 length_to_copy = n; 823 break = "0"b; 824 end; 825 sci = 0; 826 do length_to_copy = length_to_copy repeat (length_to_copy - n) while (length_to_copy > 0); 827 if read_entry 828 then do; 829 n = min (length_to_copy, transmit_info (tidx).size); 830 call copy_from_us_to_user (cscp, sci, n, tidx, 0); 831 tidx = tidx + 1; 832 end; 833 else do; 834 n = min (length_to_copy, max_buffer_tally (tcp -> buffer.size_code)); 835 call copy_chars (cscp, sci, n, tcp, 0); 836 string (tcp -> buffer.flags) = "0"b; 837 tcp -> buffer.tally = n; 838 prevp = tcp; /* remind us of the last buffer used. */ 839 tcp = ptr (tcp, tcp -> buffer.next); 840 end; 841 bytes_processed = bytes_processed + n; 842 end; 843 if ^read_entry 844 then prevp -> buffer.flags.break = break; 845 if cscp = null /* we've exhausted our chain */ 846 then do; 847 call tty_space_man$free_chain (devx, INPUT, headp); 848 /* if yes, then free it. */ 849 channel.fblock, channel.lblock = 0; 850 end; 851 else do; /* if no, detach the used part */ 852 n = cscp -> buffer.tally - sci; 853 /* align the rest of the buffer where it stopped */ 854 prevp = cscp; 855 call copy_chars (prevp, sci, n, prevp, 0); 856 cscp -> buffer.tally = n; /* update the tally */ 857 i = bin (rel (cscp), 18); 858 if channel.fblock ^= i /* if we have buffers to detach */ 859 then do; /* find the last buffer seen */ 860 do blockp = headp repeat (ptr (blockp, buffer.next)) while (buffer.next ^= i); 861 end; 862 buffer.next = 0; /* cut here */ 863 channel.fblock = i; /* render to Caesar... */ 864 call tty_space_man$free_chain (devx, INPUT, headp); 865 end; 866 end; 867 end; 868 check_rest: 869 if channel.fblock ^= 0 870 then do; 871 blockp = ptr (ttybp, channel.fblock); 872 call check_length (break, n); /* what is left to us ? */ 873 rest = 0; 874 channel.flags.rflag = "0"b; 875 if break 876 then rest = n; 877 else channel.flags.rflag = "1"b; 878 end; 879 else channel.flags.rflag = "1"b; /* warn the user that ther's something new */ 880 a_bytes_processed = bytes_processed; 881 end; 882 else code = error_table_$invalid_state; 883 end; 884 885 else code = error_table_$bad_arg; 886 goto unlock; 887 888 interrupt: 889 entry (a_data_base_ptr, a_type, a_info); 890 891 /* "interrupt_side" of the protocol_mpx pseudo-multiplexer interfacing the MCS environment with the user */ 892 893 channel_ptr = a_data_base_ptr; 894 int_type = a_type; 895 interrupt_info = a_info; 896 locked = "0"b; 897 devx = channel.devx; 898 ttybp = addr (tty_buf$); 899 infop = addr (dn355_data$); 900 protocol_data_ptr = datanet_info.protocol_datap; 901 902 if int_type = DIALUP 903 then do; /* network connections - N_CON_IND */ 904 unspec (DIALUP_info) = interrupt_info; 905 if channel.state ^= HUNGUP 906 then goto bad_int; 907 blockp = ptr (ttybp, DIALUP_info.info_relp); /* recover the info transmitted by x25_mpx... */ 908 NCON_IND_info = N_I_i; 909 unspec (dialup_info) = unspec (NCON_IND_info.dial_info); 910 channel.buffer_pad = dialup_info.buffer_pad; 911 channel.max_buf_size = dialup_info.max_buf_size; 912 channel.space_left_in_packet = channel.max_packet_size; 913 channel.his_network_address = NCON_IND_info.his_address; 914 channel.call_data = NCON_IND_info.data; 915 channel.facilities = NCON_IND_info.facilities; 916 call compute_max_nsdu_size; 917 call tty_space_man$free_buffer (devx, INPUT, blockp); 918 /* return the buffer that had contained the info */ 919 process_id = ""b; 920 event = 0; 921 if length (channel.call_data) = 0 922 then protocol_id = layer3_ISO; 923 else do protocol_id = lbound (protocol_data.listeners, 1) to hbound (protocol_data.listeners, 1) 924 while (channel.call_data ^= layer3_call_datas (protocol_id)); 925 end; 926 ndis_ind_reason.cause = 0; 927 ndis_ind_reason.diag = DIAG_71; 928 if protocol_id > hbound (protocol_data.listeners, 1) 929 then do; /* not a standard protocol */ 930 n = hbound (protocol_data.special_listeners, 1); 931 stop = "0"b; 932 do i = 1 to n while (^stop); 933 m = length (protocol_data.special_listeners (i).datas); 934 if protocol_data.special_listeners (i).call_datas.partial & length (channel.call_data) >= m 935 then if substr (channel.call_data, 1, m) = protocol_data.special_listeners (i).call_datas.datas 936 then stop = "1"b; 937 if ^protocol_data.special_listeners (i).call_datas.partial 938 & channel.call_data = protocol_data.special_listeners (i).call_datas.datas 939 then stop = "1"b; 940 end; 941 if stop 942 then do; 943 i = i - 1; 944 process_id = protocol_data.special_listeners (i).proc_id; 945 event = protocol_data.special_listeners (i).event_id; 946 end; 947 end; 948 else do; 949 process_id = protocol_data.listeners (protocol_id).proc_id; 950 event = protocol_data.listeners (protocol_id).event_id; 951 end; 952 if process_id ^= ""b 953 then do; 954 protocol_msg.ev_devx = devx; 955 protocol_msg.ev_type = NCONIND; 956 protocol_msg.ev_user_index = 0; 957 protocol_msg.infos = ""b; 958 call pxss$ring_0_wakeup (process_id, event, protocol_event_message, pxss_status); 959 if bad_pxss_status () 960 then call channel_manager$control (devx, "hangup", addr (ndis_ind_reason), ignore_code); 961 else do; 962 channel.state = DIALING; 963 channel.flags.in_use = "1"b; 964 channel.listener_proc_id = process_id; 965 channel.listener_event = event; 966 end; 967 end; 968 else call channel_manager$control (devx, "hangup", addr (ndis_ind_reason), ignore_code); 969 end; 970 else if int_type = USER_INTERRUPT 971 then do; /* confirm network connection - N_CON_CONF */ 972 if channel.state = DIALING 973 then do; 974 unspec (dialup_info) = unspec (interrupt_info); 975 channel.buffer_pad = dialup_info.buffer_pad; 976 channel.max_buf_size = dialup_info.max_buf_size; 977 call compute_max_nsdu_size; 978 protocol_msg.ev_devx = devx; 979 protocol_msg.ev_type = NCONCONF; 980 protocol_msg.ev_user_index = channel.user_ref; 981 channel.state = DIALED; 982 channel.rflag = "1"b; 983 call pxss$ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 984 pxss_status); 985 if pxss_status = WAKEUP_CODE_0 | pxss_status = WAKEUP_CODE_5 | pxss_status = WAKEUP_CODE_100 986 then call channel_manager$control (devx, "hangup", null (), ignore_code); 987 end; 988 else call syserr (Log_message, "protocol_mpx: bad CON_CONF received in state ^d on devx ^d", channel.state, 989 devx); 990 end; 991 992 else if int_type = HANGUP | int_type = CRASH | int_type = DIAL_STATUS 993 /* network disconnect - N_DIS_IND */ 994 then do; 995 if channel.state = HUNGUP 996 then ; /* if already HUNGUP it's an n_dis_conf */ 997 else do; 998 unspec (protocol_msg.infos) = substr (interrupt_info, 37, 18); 999 protocol_msg.ev_devx = devx; 1000 protocol_msg.ev_type = NDISIND; 1001 protocol_msg.ev_user_index = channel.user_ref; 1002 channel.state = HUNGUP; 1003 call pxss$ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 1004 pxss_status); 1005 if channel.listener_proc_id ^= ""b 1006 then do; 1007 call pxss$ring_0_wakeup (channel.listener_proc_id, channel.listener_event, 1008 protocol_event_message, pxss_status); 1009 if bad_pxss_status () 1010 then ; /* for noting in the log */ 1011 end; 1012 call reset_channel; 1013 end; 1014 if channel.flags.started & ^channel.flags.timer_set 1015 /* we're not able to recall x25_mpx directly */ 1016 then do; 1017 call mcs_timer$set (devx, 0, clock () + MILLISECONDS_2, ""b); 1018 /* then we recall it later... */ 1019 channel.flags.timer_set = "1"b; 1020 end; 1021 end; 1022 1023 else if int_type = SEND_OUTPUT & channel.state > HUNGUP 1024 /* x25_mpx round robin */ 1025 then do; 1026 channel.flags.send_output = "1"b; 1027 if channel.write_first ^= 0 /* do we have anything left to send ? */ 1028 then call send_next_nsdu; 1029 1030 if channel.write_first = 0 | /* if there's nothing left to send or if send_next_nsdu */ 1031 channel.flags.send_output /* nothing to send (no complete NSDU in stock) */ 1032 then if channel.wflag /* user is waiting to be told when output is done */ 1033 then do; 1034 protocol_msg.ev_devx = devx; 1035 protocol_msg.ev_type = NDTRDYIND; 1036 protocol_msg.ev_user_index = channel.user_ref; 1037 call pxss$ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 1038 pxss_status); 1039 if pxss_status = WAKEUP_CODE_0 | pxss_status = WAKEUP_CODE_5 | pxss_status = WAKEUP_CODE_100 1040 then call channel_manager$control (devx, "hangup", null (), ignore_code); 1041 channel.wflag = "0"b; 1042 end; 1043 end; 1044 1045 else if int_type = ACCEPT_INPUT /* data indication - N_DATA_IND */ 1046 then do; 1047 unspec (rtx_info) = interrupt_info; 1048 inchain = bin (rtx_info.chain_head); 1049 if inchain = 0 1050 then return; 1051 1052 last_offset = bin (rtx_info.chain_tail); /* initialize end_of_chain pointer */ 1053 if channel.fblock = 0 1054 then do; /* no existing blocks */ 1055 channel.fblock = inchain; /* set offset to first block */ 1056 end; 1057 else do; 1058 old_tailp = ptr (ttybp, channel.lblock); 1059 next_offset = bin (rtx_info.chain_head); 1060 if ^old_tailp -> buffer.flags.break 1061 then do; 1062 1063 old_last_tally = old_tailp -> buffer.tally; 1064 1065 max_tally = max_buffer_tally (old_tailp -> buffer.size_code); 1066 /* number of characters this buffer will hold */ 1067 filled = "0"b; 1068 do while ((next_offset ^= 0) & ^filled); 1069 /* put as much as possible of input into last old buffer */ 1070 new_headp = ptr (ttybp, next_offset); 1071 new_first_tally = new_headp -> buffer.tally; 1072 1073 if (old_last_tally + new_first_tally <= max_tally) 1074 then do; 1075 source_ptr = addr (new_headp -> buffer.chars (0)); 1076 target_ptr = addr (old_tailp -> buffer.chars (old_last_tally)); 1077 target_ptr -> new_chars = source_ptr -> new_chars; 1078 old_last_tally = old_last_tally + new_first_tally; 1079 old_tailp -> buffer.flags.break = new_headp -> buffer.flags.break; 1080 if new_headp -> buffer.flags.break 1081 then filled = "1"b; 1082 next_offset = new_headp -> buffer.next; 1083 /* move on to next buffer */ 1084 call tty_space_man$free_buffer (devx, INPUT, new_headp); 1085 /* through with this one */ 1086 end; 1087 1088 else filled = "1"b; /* no more room in last old buffer */ 1089 end; 1090 1091 old_tailp -> buffer.tally = old_last_tally; 1092 end; 1093 old_tailp -> buffer.next = next_offset; 1094 if next_offset = 0 1095 then last_offset = 0; /* took care of entire new chain */ 1096 end; 1097 1098 if last_offset ^= 0 1099 then channel.lblock = last_offset; 1100 if rtx_info.break_char & channel.flags.rflag 1101 then do; 1102 protocol_msg.ev_devx = devx; 1103 protocol_msg.ev_type = NDTIND; 1104 protocol_msg.ev_user_index = channel.user_ref; 1105 call pxss$ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 1106 pxss_status); /* wakeup the user */ 1107 if pxss_status = WAKEUP_CODE_0 | pxss_status = WAKEUP_CODE_5 | pxss_status = WAKEUP_CODE_100 1108 then call channel_manager$control (devx, "hangup", null (), ignore_code); 1109 channel.rflag = "0"b; /* we've taken care of this now */ 1110 end; 1111 end; 1112 1113 else if int_type = LINE_STATUS /* N_RESET_IND */ 1114 then do; 1115 if channel.user_proc_id ^= "0"b 1116 then do; 1117 protocol_msg.ev_devx = devx; 1118 protocol_msg.ev_type = NRESETIND; 1119 protocol_msg.ev_user_index = channel.user_ref; 1120 call pxss$ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 1121 pxss_status); 1122 if pxss_status = WAKEUP_CODE_0 | pxss_status = WAKEUP_CODE_5 | pxss_status = WAKEUP_CODE_100 1123 then call channel_manager$control (devx, "hangup", null (), ignore_code); 1124 end; 1125 1126 return; 1127 1128 end; 1129 1130 else if int_type = TIMER 1131 then do; 1132 channel.flags.timer_set = "0"b; 1133 if channel.flags.started & channel.state = HUNGUP 1134 then call channel_manager$control (devx, "listen", null (), ignore_code); 1135 end; 1136 1137 else if int_type = SPACE_AVAILABLE /* we were waiting for space */ 1138 then do; 1139 if channel.write_first ^= 0 /* we've got more output */ 1140 then call send_next_nsdu; 1141 if channel.write_first = 0 | channel.send_output 1142 then do; 1143 protocol_msg.ev_devx = devx; 1144 protocol_msg.ev_type = NDTRDYIND; 1145 protocol_msg.ev_user_index = channel.user_ref; 1146 call pxss$unique_ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 1147 pxss_status); 1148 if pxss_status = WAKEUP_CODE_0 | pxss_status = WAKEUP_CODE_5 | pxss_status = WAKEUP_CODE_100 1149 then call channel_manager$control (devx, "hangup", null (), ignore_code); 1150 end; 1151 end; 1152 1153 else 1154 bad_int: 1155 call syserr (Log_message, "protocol_mpx: unexpected interrupt type (^d) for devx ^d in state ^d", int_type, 1156 devx, channel.state); 1157 1158 return; 1159 1160 setup: 1161 proc; 1162 1163 devx = twx; /* pull devx from user */ 1164 ttybp = addr (tty_buf$); 1165 lctp = tty_buf.lct_ptr; 1166 lcntp = lct.lcnt_ptr; 1167 infop = addr (dn355_data$); 1168 protocol_data_ptr = datanet_info.protocol_datap; 1169 if devx < 1 | devx > lct.max_no_lctes 1170 then do; 1171 code = error_table_$invalid_device; 1172 goto unlock; /* return error */ 1173 end; 1174 1175 call tty_lock$lock_channel (devx, code); /* lock the channel */ 1176 if code ^= 0 1177 then goto unlock; 1178 locked = "1"b; 1179 1180 lctep = addr (lct.lcte_array (devx)); 1181 if lcte.channel_type ^= PROTOCOL_MPX /* not our cup of tea */ 1182 then goto illdet; 1183 1184 channel_ptr = lcte.data_base_ptr; /* pointer to perm info */ 1185 if channel.user_proc_id ^= ""b & channel.listener_proc_id ^= pds$processid 1186 & channel.user_proc_id ^= pds$processid 1187 then goto illdet; 1188 return; 1189 end setup; 1190 1191 illdet: /* illegal messing with channel */ 1192 code = error_table_$io_no_permission; 1193 unlock: 1194 a_code = code; 1195 call cleaner; 1196 return; 1197 1198 get_channel: 1199 proc (addr) returns (fixed bin); 1200 1201 dcl addr char (15) varying, 1202 i fixed bin; 1203 1204 do i = protocol_data.max_channels to 1 by -1 1205 while (protocol_data.channels (i).flags.in_use | ^protocol_data.channels (i).flags.started 1206 | (protocol_data.channels (i).our_network_address ^= addr & addr ^= "")); 1207 end; 1208 return (i); 1209 end get_channel; 1210 1211 1212 check_length: 1213 proc (break_flag, length); 1214 1215 /* resend the length of the chain pointed to by blockp just at next 1216* break or just at the end of the chain if there is no break */ 1217 1218 dcl break_flag bit (1); 1219 dcl length fixed bin; 1220 dcl stop bit (1); 1221 1222 length = 0; 1223 stop, break_flag = "0"b; 1224 do blockp = blockp repeat (ptr (blockp, buffer.next)) while (^stop); 1225 if buffer.break 1226 then break_flag = "1"b; 1227 if buffer.next = 0 | break_flag 1228 then stop = "1"b; 1229 length = length + buffer.tally; 1230 end; 1231 end check_length; 1232 1233 1234 copy_chars: 1235 proc (source_ptr, source_offset, n_chars_to_copy, target_ptr, a_target_offset); 1236 1237 /* 1238* Procedure copying n_chars_to_copy characters from the chain pointed to 1239* by source_ptr to the offset source_offset in the buffer pointed to by 1240* target_ptr to the offset target_offset. No overflow test is made. On 1241* return, source_ptr and source_offset indicate the next character in the 1242* chain or source_ptr = null () if the chain is exhausted. 1243* target_offset is unchanged. 1244**/ 1245 1246 dcl (source_ptr, target_ptr) 1247 ptr; 1248 dcl (a_target_offset, n_chars_to_copy) 1249 fixed bin; 1250 dcl source_offset fixed bin (21); 1251 dcl (n, nctc, target_offset) 1252 fixed bin; 1253 dcl n_chars_in_source_buffer 1254 fixed bin; 1255 dcl source_chars char (n) based (addr (source_ptr -> buffer.chars (source_offset))); 1256 dcl target_chars char (n) based (addr (target_ptr -> buffer.chars (target_offset))); 1257 1258 target_offset = a_target_offset; 1259 1260 do nctc = n_chars_to_copy repeat (nctc - n) while (nctc > 0); 1261 n_chars_in_source_buffer = source_ptr -> buffer.tally - source_offset; 1262 if n_chars_in_source_buffer > nctc 1263 then do; 1264 n = nctc; 1265 target_chars = source_chars; 1266 source_offset = source_offset + n; 1267 end; 1268 else if n_chars_in_source_buffer < nctc 1269 then do; 1270 n = n_chars_in_source_buffer; 1271 target_chars = source_chars; 1272 if source_ptr -> buffer.next = 0 1273 then source_ptr = null; 1274 else source_ptr = ptr (source_ptr, source_ptr -> buffer.next); 1275 source_offset = 0; 1276 end; 1277 else do; 1278 n = nctc; 1279 target_chars = source_chars; 1280 if source_ptr -> buffer.next = 0 1281 then source_ptr = null; 1282 else source_ptr = ptr (source_ptr, source_ptr -> buffer.next); 1283 source_offset = 0; 1284 end; 1285 target_offset = target_offset + n; 1286 end; 1287 end copy_chars; 1288 1289 1290 1291 reset_channel: 1292 proc; 1293 1294 1295 if channel.fblock ^= 0 /* free read chain */ 1296 then call tty_space_man$free_chain (devx, INPUT, ptr (ttybp, channel.fblock)); 1297 1298 if channel.write_first ^= 0 /* free send chain */ 1299 then call tty_space_man$free_chain (devx, OUTPUT, ptr (ttybp, channel.write_first)); 1300 1301 channel.flags.in_use, channel.flags.send_output, channel.flags.wflag, channel.flags.rflag = "0"b; 1302 1303 channel.fblock, channel.lblock = 0; 1304 channel.write_first, channel.write_last = 0; 1305 channel.space_left_in_packet = channel.max_packet_size; 1306 channel.listener_event = 0; 1307 channel.listener_proc_id = ""b; 1308 channel.user_event = 0; 1309 channel.user_proc_id = ""b; 1310 channel.user_ref = 0; 1311 channel.his_network_address = ""; 1312 channel.call_data = ""; 1313 channel.facilities = ""; 1314 channel.max_buf_size = 0; 1315 channel.buffer_pad = 0; 1316 channel.max_nsdu_size = 0; 1317 1318 end reset_channel; 1319 1320 1321 1322 send_next_nsdu: 1323 proc; 1324 1325 dcl headp ptr; 1326 dcl next_head fixed bin; 1327 1328 if channel.flags.send_output 1329 then do; 1330 headp, blockp = ptr (ttybp, channel.write_first); 1331 1332 do while (buffer.next ^= 0 & ^buffer.flags.break); 1333 /* find the end of the chain or limit of NSDU */ 1334 blockp = ptr (ttybp, buffer.next); 1335 end; 1336 if ^buffer.flags.break 1337 then return; /* if no complete NSDU then return */ 1338 next_head = buffer.next; 1339 buffer.next = 0; /* break chain here */ 1340 call channel_manager$write (devx, headp, code); 1341 if code = noalloc_code 1342 then do; 1343 call tty_space_man$needs_space (devx); 1344 code = 0; /* don't treat like other error codes */ 1345 end; 1346 1347 1348 if headp ^= null /* didn't take it all */ 1349 then do; 1350 if code = 0 1351 then do; 1352 blockp = headp; 1353 do while (buffer.next ^= 0); 1354 blockp = ptr (ttybp, buffer.next); 1355 end; 1356 1357 buffer.next = next_head; /* found the end of the returned chain, reconnect it */ 1358 if next_head = 0 /* if we weren't hanging on to one */ 1359 then channel.write_last = bin (rel (blockp)); 1360 /* this is the end */ 1361 next_head = bin (rel (headp)); /* this is now head of the chain */ 1362 end; 1363 1364 else do; 1365 call tty_space_man$free_chain (devx, OUTPUT, headp); 1366 /* all output to be discarded */ 1367 protocol_msg.ev_devx = devx; 1368 protocol_msg.ev_type = NRESETIND; /* treat this like an n_reset_ind */ 1369 call pxss$unique_ring_0_wakeup (channel.user_proc_id, channel.user_event, protocol_event_message, 1370 (0)); 1371 end; 1372 end; 1373 1374 channel.write_first = next_head; 1375 if channel.write_first = 0 1376 then channel.write_last = 0; /* this must be true */ 1377 else if code ^= 0 /* in this case we'll throw away all output anyway */ 1378 then do; 1379 call tty_space_man$free_chain (devx, OUTPUT, ptr (ttybp, channel.write_first)); 1380 channel.write_first, channel.write_last = 0; 1381 end; 1382 channel.flags.send_output = "0"b; 1383 end; 1384 1385 return; 1386 end send_next_nsdu; 1387 1388 set_static: 1389 proc; 1390 1391 /* entry called once per bootload to copy error codes into internal static */ 1392 1393 noalloc_code = error_table_$noalloc; 1394 no_write_code = error_table_$invalid_write; 1395 call wire_proc$wire_me; 1396 end set_static; 1397 1398 1399 cleaner: 1400 proc; 1401 1402 if locked 1403 then do; 1404 call tty_lock$unlock_channel (devx); 1405 locked = "0"b; 1406 end; 1407 1408 end cleaner; 1409 1410 1411 bad_pxss_status: 1412 proc returns (bit (1)); 1413 1414 if pxss_status = WAKEUP_CODE_0 | pxss_status = WAKEUP_CODE_5 | pxss_status = WAKEUP_CODE_100 1415 then do; 1416 call syserr (Log_message, 1417 "protocol_mpx: Error ^d waking up listening process for channel ^a, it has probably crashed!", 1418 pxss_status, channel.name); 1419 return ("1"b); 1420 end; 1421 else return ("0"b); 1422 end bad_pxss_status; 1423 1424 1425 /**** procedure to examine the state of current connections: 1426* if the user process of a connection has departed this 1427* one receives hangup */ 1428 1429 check_orphan_connections: 1430 proc; 1431 1432 do i = 1 to protocol_data.max_channels; 1433 channel_ptr = addr (protocol_data.channels (i)); 1434 if channel.state > DIALING 1435 then do; 1436 call tc_util$validate_processid (channel.user_proc_id, code); 1437 if code ^= 0 1438 then do; 1439 call syserr (Log_message, "protocol_mpx: orphan channel found, ^a. Hanging it up...", 1440 channel.name); 1441 ndis_ind_reason.cause = 0; 1442 ndis_ind_reason.diag = DIAG_71; 1443 call tty_lock$lock_channel (channel.devx, code); 1444 if code = 0 1445 then do; 1446 call channel_manager$control (channel.devx, "hangup", addr (ndis_ind_reason), code); 1447 call tty_lock$unlock_channel (channel.devx); 1448 end; 1449 end; 1450 end; 1451 end; 1452 end check_orphan_connections; 1453 1454 1455 copy_from_user_to_us: 1456 proc (source_index, source_offset, n_chars_to_copy, target_ptr, a_target_offset); 1457 1458 /* 1459* Procedure copies n_chars_to_copy characters from the chain 1460* pointed to by source_index to the offset source_offset in the buffer (MCS 1461* type) pointed to by target_ptr to the offset target_offset. No overflow test 1462* is made. On return, source_index and source_offset indicate the next 1463* character in the source chain or source_index = 0 if the chain is exhausted. 1464* target_offset is unchanged. 1465**/ 1466 1467 dcl (target_ptr, source_chars_p) 1468 ptr; 1469 dcl source_offset fixed bin (21); 1470 dcl (source_index, a_target_offset, n_chars_to_copy) 1471 fixed bin; 1472 dcl (n, nctc, target_offset) 1473 fixed bin; 1474 dcl n_chars_in_source_buffer 1475 fixed bin (21); 1476 dcl total_string char (transmit_info (source_index).size) based (transmit_info (source_index).data_ptr); 1477 dcl source_chars char (n) based (source_chars_p); 1478 dcl target_chars char (n) based (addr (target_ptr -> buffer.chars (target_offset))); 1479 1480 target_offset = a_target_offset; 1481 1482 do nctc = n_chars_to_copy repeat (nctc - n) while (nctc > 0); 1483 source_chars_p = addr (substr (total_string, source_offset + 1, 1)); 1484 n_chars_in_source_buffer = transmit_info (source_index).size - source_offset; 1485 if n_chars_in_source_buffer > nctc 1486 then do; 1487 n = nctc; 1488 target_chars = source_chars; 1489 source_offset = source_offset + n; 1490 end; 1491 else if n_chars_in_source_buffer < nctc 1492 then do; 1493 n = n_chars_in_source_buffer; 1494 target_chars = source_chars; 1495 if source_index = transmit_info.n_entries 1496 then source_index = 0; 1497 else source_index = source_index + 1; 1498 source_offset = 0; 1499 end; 1500 else do; 1501 n = nctc; 1502 target_chars = source_chars; 1503 if source_index = transmit_info.n_entries 1504 then source_index = 0; 1505 else source_index = source_index + 1; 1506 source_offset = 0; 1507 end; 1508 target_offset = target_offset + n; 1509 end; 1510 end copy_from_user_to_us; 1511 1512 1513 copy_from_us_to_user: 1514 proc (source_ptr, source_offset, n_chars_to_copy, target_index, a_target_offset); 1515 1516 /* 1517* Procedure copies n_chars_to_copy characters from the chain (MCS type) 1518* pointed to by source_ptr to the offset source_offset in the buffer pointed to 1519* by target_index to the offset target_offset. No overflow test is made. On 1520* return source_ptr and source_offset indicate the next character in the source 1521* chain or source_ptr = null () if the chain is exhausted. target_offset is 1522* unchanged. 1523* 1524**/ 1525 1526 dcl (source_ptr, user_chars_p) 1527 ptr; 1528 dcl (source_offset, a_target_offset, target_offset) 1529 fixed bin (21); 1530 dcl (target_index, n_chars_to_copy) 1531 fixed bin; 1532 dcl (n, nctc) fixed bin; 1533 dcl n_chars_in_source_buffer 1534 fixed bin; 1535 dcl source_chars char (n) based (addr (source_ptr -> buffer.chars (source_offset))); 1536 dcl total_string char (transmit_info (target_index).size) based (transmit_info (target_index).data_ptr); 1537 dcl target_chars char (n) based (user_chars_p); 1538 1539 target_offset = a_target_offset; 1540 1541 do nctc = n_chars_to_copy repeat (nctc - n) while (nctc > 0); 1542 user_chars_p = addr (substr (total_string, target_offset + 1, 1)); 1543 n_chars_in_source_buffer = source_ptr -> buffer.tally - source_offset; 1544 if n_chars_in_source_buffer > nctc 1545 then do; 1546 n = nctc; 1547 target_chars = source_chars; 1548 source_offset = source_offset + n; 1549 end; 1550 else if n_chars_in_source_buffer < nctc 1551 then do; 1552 n = n_chars_in_source_buffer; 1553 target_chars = source_chars; 1554 if source_ptr -> buffer.next = 0 1555 then source_ptr = null (); 1556 else source_ptr = ptr (source_ptr, source_ptr -> buffer.next); 1557 source_offset = 0; 1558 end; 1559 else do; 1560 n = nctc; 1561 target_chars = source_chars; 1562 if source_ptr -> buffer.next = 0 1563 then source_ptr = null (); 1564 else source_ptr = ptr (source_ptr, source_ptr -> buffer.next); 1565 source_offset = 0; 1566 end; 1567 target_offset = target_offset + n; 1568 end; 1569 end copy_from_us_to_user; 1570 1571 compute_max_nsdu_size: 1572 proc; 1573 1574 dcl i fixed bin; 1575 1576 max_chars_in_buf = SIZE4 * (channel.max_buf_size - 1) - channel.buffer_pad; 1577 i = ceil (channel.max_packet_size / max_chars_in_buf); 1578 /* number of buffers/x25 packet */ 1579 channel.max_nsdu_size = min (LONGEST_POSSIBLE_STRING, (max_chain_len / i) * channel.max_packet_size); 1580 end compute_max_nsdu_size; 1581 1582 1 1 /* -------- BEGIN INCLUDE FILE ... protocol_data.incl.pl1 --------- */ 1 2 1 3 1 4 /****^ HISTORY COMMENTS: 1 5* 1) change(89-03-20,Parisek), approve(89-06-06,MCR8110), 1 6* audit(89-10-09,Farley), install(89-10-25,MR12.3-1100): 1 7* Add support of protocol mpx. 1 8* END HISTORY COMMENTS */ 1 9 1 10 /* Written 15 May 1985 by C. Claveleira - CICB */ 1 11 1 12 /* Latest revision : */ 1 13 /* */ 1 14 /* 7 oct 1985 by C. Claveleira */ 1 15 /* 19 oct 1985 by C. Claveleira */ 1 16 /* 26 dec 1985 by C. Claveleira */ 1 17 /* 14 fev 1986 by C. Claveleira */ 1 18 /* 20 mar 1986 by C. Claveleira - version 1.0 of protocol_mpx */ 1 19 /* 02 sep 1986 by C. Claveleira - version 1.6 of protocol_mpx */ 1 20 /* 26 nov 1986 by C. Claveleira - version 1.8 of protocol_mpx */ 1 21 1 22 dcl protocol_data_ptr ptr; 1 23 dcl protocol_channels fixed bin; 1 24 1 25 dcl 1 protocol_data aligned based (protocol_data_ptr), 1 26 1 27 2 max_channels fixed bin, /* maximum number of channels (filled by fnp_init) */ 1 28 2 n_channels fixed bin, /* # of initialized channels */ 1 29 2 init_time fixed bin (71), 1 30 2 listeners (4), /* array of listeners processes by protocol type */ 1 31 3 proc_id bit (36), 1 32 3 pad1 bit (36), 1 33 3 event_id fixed bin (71), 1 34 2 special_listeners (10), /* array of non-standards protocols listened */ 1 35 3 call_datas, 1 36 4 partial bit (1) unal, /* ON if test on first part of call_datas */ 1 37 4 pad2 bit(35) unal, 1 38 4 datas char (48) varying, /* call_datas that must match */ 1 39 3 proc_id bit (36), /* process_id of listener */ 1 40 3 pad3 bit (36), 1 41 3 event_id fixed bin (71), /* event of listener */ 1 42 2 channels (protocol_channels refer (protocol_data.max_channels)) like channel; 1 43 1 44 dcl channel_ptr ptr; 1 45 1 46 dcl 1 channel aligned based (channel_ptr), /* entry is 58 words wide */ 1 47 2 name char (32), /* name from lcnt */ 1 48 2 devx fixed bin (17), /* index in lct */ 1 49 2 state fixed bin, /* see values below */ 1 50 2 load_proc_id bit (36), /* process_id of loader process */ 1 51 2 flags, 1 52 3 initialized bit (1) unal, /* ON after init_multiplexer */ 1 53 3 started bit (1) unal, /* ON after start */ 1 54 3 in_use bit (1) unal, /* ON if line currently in use */ 1 55 3 send_output bit (1) unal, /* ON if we can send more output */ 1 56 3 wflag bit (1) unal, /* ON if process blocked on output */ 1 57 3 rflag bit (1) unal, /* ON if process blocked on input */ 1 58 3 timer_set bit (1) unal, /* ON if timer set for this channel */ 1 59 3 pad bit (29) unal, 1 60 2 listener_proc_id bit (36), /* proc_id of listener process */ 1 61 2 pad5 bit (36), 1 62 2 listener_event fixed bin (71), /* event_channel of listener */ 1 63 2 user_proc_id bit (36), /* process_id of current user */ 1 64 2 pad6 bit (36), 1 65 2 user_event fixed bin (71), /* event_channel of user */ 1 66 2 user_ref fixed bin (17), /* user's internal ref */ 1 67 2 max_packet_size fixed bin, /* x25's max data packet size */ 1 68 2 our_network_address char (15) varying, /* network address of this channel */ 1 69 2 his_network_address char (15) varying, /* network address of remote */ 1 70 2 call_data char (48) varying, /* call datas from remote */ 1 71 2 facilities char (16) varying, /* facilities from remote */ 1 72 2 fblock fixed bin (17), /* offset of first data block. Input */ 1 73 2 lblock fixed bin (17), /* " " last " " " */ 1 74 2 write_first fixed bin (17), /* " " first " " . Output */ 1 75 2 write_last fixed bin (17), /* " " last " " " */ 1 76 2 space_left_in_packet fixed bin, /* current space left in x25 data packet */ 1 77 2 max_buf_size fixed bin (9) uns, /* maximum buffer size we're allowed to get */ 1 78 2 buffer_pad fixed bin (9) uns, /* buffer padding we must respect */ 1 79 2 max_nsdu_size fixed bin; /* maximum size of NSDU permitted */ 1 80 1 81 dcl (INACTIVE init (0), /* values of channel.state */ 1 82 HUNGUP init (1), 1 83 DIALING init (2), 1 84 DIALED init (3) 1 85 ) fixed bin static options (constant); 1 86 1 87 /* ---------- End include file protocol_data.incl.pl1 ---------- */ 1583 1584 2 1 /* ---------------- BEGIN include file protocol_infos.incl.pl1 ------------- */ 2 2 2 3 2 4 2 5 /****^ HISTORY COMMENTS: 2 6* 1) change(89-03-20,Parisek), approve(89-06-06,MCR8110), 2 7* audit(89-10-09,Farley), install(89-10-25,MR12.3-1100): 2 8* Add support of protocol mpx. 2 9* 2) change(89-11-03,Parisek), approve(89-11-03,PBF8110), 2 10* audit(89-11-03,Farley), install(89-11-08,MR12.3-1107): 2 11* Move the "transmit_info.pad1" field to the proper location, 2 12* (after the "size" field). 2 13* END HISTORY COMMENTS */ 2 14 2 15 2 16 /* Written in June 1985 by C. Claveleira - CICB */ 2 17 2 18 /* Latest version : */ 2 19 /* */ 2 20 /* 14 feb 1986 : C. Claveleira */ 2 21 /* 20 mar 1986 : C. Claveleira - version 1.0 of protocol_mpx */ 2 22 /* 31 may 1986 : C. Claveleira - version 1.3 of protocol_mpx */ 2 23 2 24 /* infos exchanged between x25_mpx, protocol_mpx and 2 25* Transport Layer */ 2 26 2 27 dcl pinfop ptr; 2 28 2 29 dcl 1 DIALUP_info aligned, 2 30 2 info_relp bit (18) unaligned, 2 31 2 pad bit (54) unaligned; 2 32 2 33 dcl 1 NCON_REQ_info aligned based (pinfop), 2 34 2 mbz fixed bin (35), 2 35 2 from_address char (15) varying, 2 36 2 to_address char (15) varying, 2 37 2 facilities char (16) varying, 2 38 2 data char (48) varying; 2 39 2 40 dcl 1 NCON_IND_info aligned, 2 41 2 dial_info bit (72), 2 42 2 his_address char (15) varying, 2 43 2 our_address char (15) varying, 2 44 2 data char (48) varying, 2 45 2 facilities char (16) varying; 2 46 2 47 dcl 1 NDIS_IND_REASON aligned based, 2 48 2 cause fixed bin (8) unaligned, 2 49 2 diag fixed bin (8) unaligned; 2 50 2 51 dcl 1 disconnect_info unal, 2 52 2 cause bit (9), 2 53 2 diag bit (9); 2 54 2 55 dcl 1 network_infos aligned based (pinfop), 2 56 2 network_address char (15) varying, 2 57 2 max_packet_size fixed bin; 2 58 2 59 dcl transmit_info_entries fixed bin; 2 60 2 61 dcl 1 transmit_info aligned based (pinfop), 2 62 2 n_entries fixed bin, 2 63 2 pad bit (36), 2 64 2 entry (transmit_info_entries refer (transmit_info.n_entries)), 2 65 3 data_ptr ptr, 2 66 3 size fixed bin (21) unsigned, 2 67 3 pad1 bit (36); 2 68 2 69 2 70 /* messages passed to the Transport Layer at the time of wakeups : */ 2 71 2 72 dcl protocol_event_message fixed bin (71); 2 73 2 74 dcl 1 protocol_msg based (addr (protocol_event_message)), 2 75 2 ev_devx fixed bin (17) unaligned, /* device index */ 2 76 2 ev_type fixed bin (17) unaligned, /* reason for wakeup (see below) */ 2 77 2 ev_user_index fixed bin (17) unaligned, 2 78 2 infos bit (18) unaligned; 2 79 2 80 dcl NCONIND fixed bin internal static options (constant) init (1); /* type of wakeup */ 2 81 dcl NCONCONF fixed bin internal static options (constant) init (2); 2 82 dcl NDTIND fixed bin internal static options (constant) init (3); 2 83 dcl NDTRDYIND fixed bin internal static options (constant) init (4); 2 84 dcl NRESETIND fixed bin internal static options (constant) init (5); 2 85 dcl NDISIND fixed bin internal static options (constant) init (6); 2 86 dcl ABORT fixed bin internal static options (constant) init (7); 2 87 2 88 dcl wakeup_names (7) char (9) internal static options (constant) 2 89 init ("NCONIND", 2 90 "NCONCONF", 2 91 "NDTIND", 2 92 "NDTRYIND", 2 93 "NRESETIND", 2 94 "NDISIND", 2 95 "ABORT"); 2 96 2 97 /* --------- END INCLUDE FILE ... protocol_infos.incl.pl1 ------- */ 2 98 1585 1586 3 1 /* ------------------ BEGIN include file protocols.incl.pl1 -------------- */ 3 2 3 3 3 4 3 5 /****^ HISTORY COMMENTS: 3 6* 1) change(89-03-16,Parisek), approve(89-10-25,MECR0012), 3 7* audit(89-10-25,Farley), install(89-10-25,MR12.3-1100): 3 8* Add support of protocol mpx. 3 9* END HISTORY COMMENTS */ 3 10 3 11 /* Ecrit en mars 1986 par C. Claveleira - CICB */ 3 12 3 13 /* Derniere version : */ 3 14 /* */ 3 15 /* 14 mars 1986 : C. Claveleira */ 3 16 /* 26 nov. 1986 : C. Claveleira - version 1.8 of protocol_mpx */ 3 17 3 18 dcl layer3_ISO fixed bin static options (constant) init (1); 3 19 dcl layer3_IP fixed bin static options (constant) init (2); 3 20 dcl layer3_X29 fixed bin static options (constant) init (3); 3 21 dcl layer3_XNS fixed bin static options (constant) init (4); 3 22 3 23 3 24 dcl layer3_call_datas (4) char (48) varying static options (constant) init ( 3 25 "", /* 3,1,1,0 */ 3 26 "Ì", /* $CC */ 3 27 "", /* 1,0,0,0 */ 3 28 "" /* inconnu pour l'instant ! */ 3 29 ); 3 30 3 31 /* ---------- END INCLUDE FILE ... protocols.incl.pl1 --------- */ 1587 1588 4 1 /* Begin include file ..... multiplexer_types.incl.pl1 */ 4 2 4 3 4 4 4 5 /****^ HISTORY COMMENTS: 4 6* 1) change(89-03-20,Parisek), approve(89-06-01,MCR8110), 4 7* audit(89-10-09,Farley), install(89-10-25,MR12.3-1100): 4 8* Add support of protocol mpx. 4 9* END HISTORY COMMENTS */ 4 10 4 11 4 12 /* This include file defines known multiplexer types */ 4 13 /* Prepared August 1978 by Larry Johnson */ 4 14 /* Changed April 1979 to rename the fnp multiplexer mcs */ 4 15 4 16 dcl (TTY_MPX init (0), /* nonmultiplexed channel */ 4 17 MCS_MPX init (1), /* FNP running MCS */ 4 18 USER1_MPX init (2), /* a range of values for user defined multiplexers */ 4 19 USER2_MPX init (3), 4 20 USER3_MPX init (4), 4 21 USER4_MPX init (5), 4 22 USER5_MPX init (6), 4 23 IBM3270_MPX init (7), /* IBM 3270 display terminal controller */ 4 24 VIP7760_MPX init (8), /* Honeywell VIP 7760 terminal controller */ 4 25 STY_MPX init (9), /* Software Terminal Facility */ 4 26 LAP_MPX init (10), /* Link Access Protocol (X.25 level 2) */ 4 27 X25_MPX init (11), /* CCITT X.25 level 3 */ 4 28 HASP_MPX init (12), /* HASP RJE protocol */ 4 29 UNCP_MPX init (13), /* DSA protocol */ 4 30 SYSTEM2_MPX init (14), 4 31 SYSTEM1_MPX init (15), 4 32 PROTOCOL_MPX init (16)) /* TCP/IP network X.25 protocol */ 4 33 int static options (constant); 4 34 4 35 dcl mpx_types (0:16) char (32) int static options (constant) init ( 4 36 "tty", "mcs", "user1", "user2", "user3", "user4", "user5", "ibm3270", 4 37 "vip7760", "sty", "lap", "x25", "hasp", "uncp", "system2", "system1", 4 38 "protocol"); 4 39 4 40 dcl mpx_special_lock (0:16) bit (1) int static options (constant) init ( 4 41 "0"b, "1"b, "0"b, "0"b, "0"b, "0"b, "0"b, "0"b, 4 42 "0"b, "0"b, "0"b, "0"b, "0"b, "1"b, "0"b, "0"b, "0"b); 4 43 4 44 /* End include file ..... multiplexer_types.incl.pl1 */ 1589 1590 5 1 /* BEGIN INCLUDE FILE ... tty_buf.incl.pl1 */ 5 2 5 3 /* Date Last Modified and Reason 5 4* Created 04/19/77 by J. Stern (from part of tty.incl.pl1) 5 5* Modified January 1978 by Robert Coren and Larry Johnson for variable-size buffers 5 6* Modified 2/6/78 by Robert Coren to make circular_queue size settable 5 7* Modified Aug 78 by J. Nicholls to move the buffer block format to a file of its own 5 8* and wtcb to its own plus other modification for ring 0 multiplexing, tty_buffer_block.incl.pl1 5 9* Modified 7/17/79 by B. Greenberg for echo negotiation meters. 5 10* Modified November 1979 by C. Hornig for MCS tracing. 5 11* Modified December 1979 by Robert Coren to add FNP channel lock meter 5 12* Modified February 1980 by Robert Coren to remove all references to circular buffer 5 13* Modified March 1980 by Robert Coren to reorganize metering information 5 14* Modified December 1980 by Robert Coren to add FNP-specific events 5 15* Modified 24 March 1982, W. Olin Sibert, to add mcs_timer support, recoverable_error_severity 5 16* Modified November 1984 by Robert Coren to add tty_area_lock 5 17**/ 5 18 5 19 dcl ttybp ptr, 5 20 tty_buf$ ext static, /* tty buffer segment */ 5 21 tty_ev fixed bin int static options (constant) init (57), /* event used for wait and notify */ 5 22 abs_buf_limit fixed bin (18) static options (constant) init (64), /* minimum number of words we will leave free */ 5 23 input_bpart fixed bin (18) static options (constant) init (2), /* fraction of bleft we will allow for input */ 5 24 output_bpart fixed bin (18) static options (constant) init (4); /* fraction of bleft we will allow for output */ 5 25 5 26 5 27 dcl qblock_size fixed bin int static options (constant) init (16); /* size in words of a delay queue block */ 5 28 dcl bsizec fixed bin int static options (constant) init (60); /* number of characters in smallest buffer */ 5 29 dcl buf_per_second fixed bin int static options (constant) init (10); /* for figuring out max. buffer size based on speed */ 5 30 5 31 dcl FNP_DUMP_PATCH_EVENT fixed bin int static options (constant) init (58); 5 32 dcl FNP_METER_EVENT fixed bin int static options (constant) init (59); 5 33 dcl TTY_AREA_LOCK_EVENT bit (36) aligned int static options (constant) init ("74"b3); 5 34 5 35 dcl 1 tty_buf aligned based (ttybp), /* declaration of tty buffer seg */ 5 36 2 slock bit (36), /* per system lock */ 5 37 2 absorig fixed bin (24), /* abs address of this seg */ 5 38 2 borig bit (18), /* index of start of buffer area */ 5 39 2 bleft fixed bin (18), /* words left in pool */ 5 40 2 free bit (18), /* pointer to start of free pool */ 5 41 2 fnp_config_flags (8) bit (1) unal, /* flag(i) ON if fnp(i) configured */ 5 42 2 padb1 bit (28) unaligned, 5 43 2 lct_ptr ptr, /* pointer to logical channel table */ 5 44 5 45 2 nrawread fixed bin (35), /* number of raw chars input, total */ 5 46 2 nrawwrite fixed bin (35), /* number of raw characters output */ 5 47 2 ninchars fixed bin (35), /* total input chars after conversion */ 5 48 2 noutchars fixed bin (35), /* total output chars before conversion */ 5 49 2 readblocked fixed bin (35), /* number of times go input blocked */ 5 50 2 nblocked fixed bin (35), /* number of times process output blocked */ 5 51 2 minbuf fixed bin (18), /* min output buffer size */ 5 52 2 totbuf fixed bin (35), /* divide by nblocked to get ave buffer size */ 5 53 5 54 2 preconverted fixed bin (35), /* number of converted chars held in tty_buf */ 5 55 2 input_restart fixed bin, /* number of times tty_read had to start over */ 5 56 2 output_restart fixed bin, /* number of times tty_write has had to start over */ 5 57 2 output_buffer_overflow fixed bin, /* number of times tty_write has run out of buffers */ 5 58 2 read_time fixed bin (71), /* total time spent in tty_read */ 5 59 2 write_time fixed bin (71), /* total time spent in tty_write */ 5 60 5 61 2 read_calls fixed bin (35), /* number of calls to tty_read */ 5 62 2 write_calls fixed bin (35), /* number of calls to tty_write */ 5 63 2 bfx fixed bin, /* used in calls to iobm */ 5 64 2 nquits fixed bin (35), /* number of quits */ 5 65 2 space_needed_data, 5 66 3 space_needed bit (1) unal, /* space_needed bit on in at least 1 lcte */ 5 67 3 space_needed_calls fixed bin (34) unal, /* meter of uses of this facility */ 5 68 2 space_lock_count fixed bin (35), /* count of times tty_buf.slock locked */ 5 69 2 space_lock_wait_count fixed bin (35), /* count of times necessary to loop to lock it */ 5 70 2 space_lock_wait_time fixed bin (35), /* total time looped trying to lock it */ 5 71 5 72 2 alloc_calls fixed bin (35), /* total number of allocations performed in tty_buf */ 5 73 2 free_calls fixed bin (35), /* total number of freeings in tty_buf */ 5 74 2 alloc_time fixed bin (35), /* time spent masked in tty_space_man$get entries */ 5 75 2 free_time fixed bin (35), /* time spent masked in tty_space_man$free entries */ 5 76 2 total_alloc_steps fixed bin (35), /* number of steps thru free chain while doing above */ 5 77 2 alloc_failures fixed bin (35), /* number of unsuccessful attempts to allocate space */ 5 78 2 cumulative_input_space fixed bin (71), /* cumulative amount of space allocated for input */ 5 79 5 80 2 cumulative_output_space fixed bin (71), /* cumulative amount of space allocated for output */ 5 81 2 cumulative_control_space fixed bin (71), /* cumulative amount of space allocated by tty_space_man$get_space */ 5 82 2 input_space_updates fixed bin (35), /* number of increments to cumulative_input_space */ 5 83 2 output_space_updates fixed bin (35), /* number of increments to cumulative_output_space */ 5 84 2 control_space_updates fixed bin (35), /* number of increments to cumulative_control_space */ 5 85 2 minimum_free_space fixed bin (18), /* smallest amount of free space ever available */ 5 86 5 87 2 current_input_space fixed bin (18), /* amount of space currently allocated for input */ 5 88 2 current_output_space fixed bin (18), /* amount of space currently allocated for output */ 5 89 2 current_control_space fixed bin (18), /* amount of space currently allocated by get_space */ 5 90 2 tty_lock_calls fixed bin (35), /* number of calls to tty_lock$lock entries */ 5 91 2 found_channel_locked fixed bin (35), /* number of times tty_lock found channel already locked */ 5 92 2 max_wait_time fixed bin (35), /* longest time waited for any channel lock */ 5 93 2 total_wait_time fixed bin (71), /* total amount of time spent waiting for channel locks */ 5 94 5 95 2 echo_neg_time fixed bin (71), /* cumulative time spent doing echo negotiation */ 5 96 2 echo_neg_interrupts fixed bin (35), /* Echo-negotiated shipments */ 5 97 2 echo_neg_r0_chars fixed bin (35), /* Chars echoed by ring 0 */ 5 98 2 echo_neg_mux_chars fixed bin (35), /* Chars echoed by mux */ 5 99 2 echo_neg_sndopt_restarts fixed bin (35), /* Echo reinits */ 5 100 2 echo_neg_mux_nonecho fixed bin (35), 5 101 2 echo_neg_entries fixed bin (35), /* Entries into negotiate */ 5 102 5 103 2 echo_neg_mux_inhibit bit (1) aligned, /* For testing */ 5 104 2 n_queued_interrupts fixed bin (35), /* number of interrupts queued by tty_lock */ 5 105 2 trace unaligned, /* tracing information */ 5 106 3 flags, 5 107 4 enable bit, /* global tracing control */ 5 108 4 default_mode bit, /* whether to trace channels by default */ 5 109 4 read bit, /* read */ 5 110 4 write bit, /* write */ 5 111 4 data bit, /* buffers on reads and writes */ 5 112 4 control bit, /* control, priv_control, and hpriv_control */ 5 113 4 modes bit, /* (get set check)_modes */ 5 114 4 interrupt bit, /* interrupt, interrupt_later */ 5 115 4 init bit, /* init_multiplexer, terminate_multiplexer */ 5 116 4 start bit, /* start, stop */ 5 117 4 shutdown bit, /* shutdown */ 5 118 4 space_man bit, /* tty_space_man$* */ 5 119 4 pad_flags bit (6), 5 120 3 data_offset bit (18), /* offset of tracing data */ 5 121 5 122 2 recoverable_error_severity fixed bin, /* Syserr severity for recoverable MCS errors */ 5 123 5 124 2 timer_lock bit (36) aligned, /* Lock owned by mcs_timer */ 5 125 2 next_timer_offset bit (18) aligned, /* Offset of next timer to come due */ 5 126 2 timer_count fixed bin, /* Number of timers outstanding */ 5 127 2 timer_process bit (36) aligned, /* Who is doing timers? */ 5 128 5 129 2 timer_ev_chn fixed bin (71), /* How get get him */ 5 130 2 timer_lock_wait_time fixed bin (71), /* CPU time spent spinning on timer lock */ 5 131 5 132 2 timer_lock_count fixed bin (35), /* Number of times timer lock locked */ 5 133 2 timer_lock_wait_count fixed bin (35), /* Number of times imer lock waited on */ 5 134 2 timer_call_time fixed bin (71), /* CPU time spent in call side timer operations */ 5 135 5 136 2 timer_polling_time fixed bin (71), /* CPU time spent polling (including channel_manager) */ 5 137 2 timer_set_calls fixed bin (35), /* Number of calls to mcs_timer$set, set_wired */ 5 138 2 timer_reset_calls fixed bin (35), /* Number of calls to mcs_timer$reset, reset_wired */ 5 139 5 140 2 timer_change_calls fixed bin (35), /* Number of calls to mcs_timer$change, change_wired */ 5 141 2 timer_poll_calls fixed bin (35), /* Number of calls to mcs_timer$poll */ 5 142 2 timer_error_calls fixed bin (35), /* Number of mcs_timer calls ending with recoverable errors */ 5 143 2 timer_duplicate_pollings fixed bin (35), /* Number of timer polling found in progress on other CPU */ 5 144 5 145 2 tty_area_lock like hc_fast_lock, /* to prevent contention in allocating/freeing in tty_area */ 5 146 5 147 2 pad2 (13) fixed bin (35), 5 148 5 149 2 free_space fixed bin; /* start of free space region */ 5 150 5 151 6 1 /* BEGIN INCLUDE FILE...hc_fast_lock.incl.pl1 */ 6 2 6 3 /* Created November 1984 by Robert Coren to replace hc_lock.incl.pl1 */ 6 4 6 5 /* Lock format suitable for use with lock$lock_fast, unlock_fast */ 6 6 6 7 /* format: style3 */ 6 8 6 9 declare lock_ptr pointer; 6 10 declare 1 hc_fast_lock aligned based (lock_ptr), 6 11 2 pid bit (36) aligned, /* holder of lock */ 6 12 2 event bit (36) aligned, /* event associated with lock */ 6 13 2 flags aligned, 6 14 3 notify_sw bit (1) unaligned, 6 15 3 pad bit (35) unaligned; /* certain locks use this pad, like dirs */ 6 16 6 17 /* END INCLUDE FILE...hc_fast_lock.incl.pl1 */ 5 152 5 153 5 154 /* END INCLUDE FILE ... tty_buf.incl.pl1 */ 1591 1592 7 1 /* BEGIN INCLUDE FILE ... tty_buffer_block.incl.pl1 */ 7 2 7 3 7 4 7 5 /****^ HISTORY COMMENTS: 7 6* 1) change(88-06-15,Berno), approve(88-07-13,MCR7928), 7 7* audit(88-06-15,Parisek), install(88-07-19,MR12.2-1061): 7 8* Add data needed for the uncp multiplexer (DSA gateway) interface 7 9* implementation. 7 10* END HISTORY COMMENTS */ 7 11 7 12 7 13 /* 7 14* Separated from tty_buf.incl.pl1 aug 78 by J. Nicholls 7 15* Modified May 1979 by Larry Johnson to add max_buffer_tally array and to use unsigned variables. 7 16* Reported in February 1982 the modifications to add the "turn" bit in flags. 7 17**/ 7 18 7 19 dcl blockp ptr; /* pointer which block entry is based on */ 7 20 dcl free_blockp ptr; /* pointer to head of free space chain */ 7 21 7 22 7 23 dcl 1 free_block aligned based (free_blockp), /* format of start of free block */ 7 24 2 next bit (18), /* foward pointer to next free block */ 7 25 2 size fixed bin; /* number of words in this block */ 7 26 7 27 7 28 dcl 1 buffer based (blockp) aligned, /* buffer definition */ 7 29 2 next fixed bin (18) unal uns, /* addr of next buffer */ 7 30 2 flags unaligned, 7 31 3 end_of_page bit (1) unaligned, /* buffer contains end of page */ 7 32 3 converted bit (1) unaligned, /* buffer contains converted input */ 7 33 3 break bit (1) unaligned, /* buffer contains break character */ 7 34 3 mark bit (1) unaligned, /* buffer contains first character after "mark" */ 7 35 3 turn bit (1) unaligned, /* ON if the turn must be sent */ 7 36 3 pad bit (1) unaligned, 7 37 2 size_code fixed bin (3) unal uns, /* (nwords/16) - 1 */ 7 38 2 tally fixed bin (9) unal uns, /* number of characters in buffer */ 7 39 2 chars (0:59) char (1) unaligned; /* room for 60 data characters */ 7 40 7 41 /* the following array, if indexed by buffer.size_code will give maximum number of characters permitted in that buffer */ 7 42 7 43 dcl max_buffer_tally (0:7) fixed bin int static options (constant) init (60, 124, 188, 252, 316, 380, 444, 508); 7 44 7 45 /* END INCLUDE FILE ... tty_buffer_block.incl.pl1 */ 1593 1594 8 1 /* BEGIN INCLUDE FILE ... tty_space_man_dcls.incl.pl1 */ 8 2 8 3 /* This include file declares all the entries in tty_space_man and defines the constants 8 4** to be used for the flags argument 8 5** Modified 08/21/78 by Robert Coren to eliminate "masked" flag 8 6** Modified March 1981 by Robert Coren to add get_perm_space entry 8 7** Modified April 1981 by Robert Coren to add switch_chain entry 8 8**/ 8 9 8 10 dcl tty_space_man$get_space entry (fixed bin, ptr); 8 11 dcl tty_space_man$get_perm_space entry (fixed bin, ptr); 8 12 dcl tty_space_man$free_space entry (fixed bin, ptr); 8 13 dcl tty_space_man$get_buffer entry (fixed bin, fixed bin, bit (1), ptr); 8 14 dcl tty_space_man$free_buffer entry (fixed bin, bit (1), ptr); 8 15 dcl tty_space_man$get_chain entry (fixed bin, fixed bin, fixed bin, bit (1), ptr); 8 16 dcl tty_space_man$free_chain entry (fixed bin, bit (1), ptr); 8 17 dcl tty_space_man$switch_chain entry (fixed bin, fixed bin, bit (1), bit (1), ptr); 8 18 dcl tty_space_man$needs_space entry (fixed bin); 8 19 8 20 dcl INPUT bit (1) int static options (constant) init ("0"b); 8 21 dcl OUTPUT bit (1) int static options (constant) init ("1"b); 8 22 8 23 /* END INCLUDE FILE ... tty_space_man_dcls.incl.pl1 */ 1595 1596 9 1 /* BEGIN INCLUDE FILE ... lct.incl.pl1 */ 9 2 9 3 /* Created by J. Stern 7/26/78 */ 9 4 /* Metering information added by C. Hornig, March 1980. */ 9 5 /* Unwired saved meters added by Robert Coren, December 1980 */ 9 6 9 7 dcl lctp ptr; /* ptr to logical channel table */ 9 8 dcl lctep ptr; /* ptr to logical channel table entry */ 9 9 dcl lct_size fixed bin; /* size of lcte_array when allocated */ 9 10 9 11 dcl 1 lct aligned based (lctp), /* logical channel table */ 9 12 2 max_no_lctes fixed bin, /* maximum number of lct entries */ 9 13 2 cur_no_lctes fixed bin, /* current number of lct entries used */ 9 14 2 lcnt_ptr ptr, /* ptr to logical channel name table */ 9 15 2 queue_lock bit (36), /* lock used to serialize queueing operations */ 9 16 2 pad (11) fixed bin, 9 17 2 lcte_array (lct_size refer (lct.max_no_lctes)) like lcte; /* lct entries */ 9 18 9 19 9 20 dcl 1 lcte aligned based (lctep), /* logical channel table entry */ 9 21 2 lock bit (36), /* channel lock */ 9 22 2 data_base_ptr ptr unal, /* ptr to channel data base */ 9 23 2 channel_type fixed bin (8) unal, /* identifies channel manager program */ 9 24 2 flags unal, 9 25 3 entry_in_use bit (1) unal, /* ON if this entry in use */ 9 26 3 initialized bit (1) unal, /* ON if this channel initialized */ 9 27 3 notify_reqd bit (1) unal, /* ON if must notify when unlocking this channel */ 9 28 3 locked_for_interrupt bit (1) unal, /* ON if lock set by interrupt handler */ 9 29 3 space_needed bit (1) unal, /* ON if this channel needs buffer space */ 9 30 3 special_lock bit (1) unal, /* ON if lock is managed by multiplexer */ 9 31 3 trace_force bit (1) unal, /* ON to trace based on next bit only */ 9 32 /* OFF to XOR next bit with tty_buf.default_tracing */ 9 33 3 trace bit (1) unal, /* ON to trace this channel */ 9 34 3 unused bit (1) unal, 9 35 2 physical_channel_devx fixed bin (17) unal, /* devx of physical chan from which logical chan is derived */ 9 36 2 major_channel_info, 9 37 3 major_channel_devx fixed bin unal, /* major channel device index */ 9 38 3 subchannel fixed bin (17) unal, /* subchannel id (or data ptr) wrt major channel */ 9 39 2 queue_entries, 9 40 3 queue_head bit (18) unal, /* ptr to first queue entry for this channel */ 9 41 3 queue_tail bit (18) unal, /* ptr to last queue entry for this channel */ 9 42 2 word_counts, 9 43 3 input_words fixed bin (17) unal, /* number of input words charged to this channel */ 9 44 3 output_words fixed bin (17) unal, /* number of output words charged to this channel */ 9 45 9 46 2 meters, 9 47 3 in_bytes fixed bin (35), 9 48 3 out_bytes fixed bin (35), 9 49 3 in, 9 50 4 calls fixed bin (35), 9 51 4 interrupts fixed bin (35), 9 52 4 call_time fixed bin (71), 9 53 4 interrupt_time fixed bin (71), 9 54 3 out like lcte.meters.in, 9 55 3 control like lcte.meters.in, 9 56 2 saved_meters_ptr ptr, /* pointer to unwired copy of meters saved at last dialup */ 9 57 9 58 2 timer_offset bit (18) aligned, /* Head of list of timers for this channel */ 9 59 9 60 2 pad (3) fixed bin (35); 9 61 9 62 9 63 dcl lcntp ptr; /* ptr to logical channel name table */ 9 64 9 65 dcl 1 lcnt aligned based (lcntp), /* logical channel name table */ 9 66 2 names (lct.max_no_lctes) char (32) unal; /* channel names */ 9 67 9 68 dcl 1 saved_meters aligned based like lcte.meters; /* meters saved at dialup, allocated in tty_area */ 9 69 9 70 9 71 /* END INCLUDE FILE ... lct.incl.pl1 */ 1597 1598 10 1 /* BEGIN INCLUDE FILE ... channel_manager_dcls.incl.pl1 */ 10 2 10 3 /* Created 8/25/78 by J. Stern */ 10 4 10 5 10 6 /* call channel_manager$read (devx, chain_ptr, more_input_flag, code) */ 10 7 dcl channel_manager$read entry (fixed bin, ptr, bit (1) aligned, fixed bin (35)); 10 8 10 9 /* call channel_manager$write (devx, output_ptr, code) */ 10 10 dcl channel_manager$write entry (fixed bin, ptr, fixed bin (35)); 10 11 10 12 /* call channel_manager$control (devx, control_type, info_ptr, code) */ 10 13 dcl channel_manager$control entry (fixed bin, char (*), ptr, fixed bin (35)); 10 14 10 15 /* call channel_manager$set_modes (devx, mode_change_list_ptr, code) */ 10 16 dcl channel_manager$set_modes entry (fixed bin, ptr, fixed bin (35)); 10 17 10 18 /* call channel_manager$check_modes (devx, mode_change_list_ptr, code) */ 10 19 dcl channel_manager$check_modes entry (fixed bin, ptr, fixed bin (35)); 10 20 10 21 /* call channel_manager$get_modes (devx, modes, code) */ 10 22 dcl channel_manager$get_modes entry (fixed bin, char (*), fixed bin (35)); 10 23 10 24 /* call channel_manager$interrupt (devx, int_type, int_data) */ 10 25 dcl channel_manager$interrupt entry (fixed bin, fixed bin, bit (72) aligned); 10 26 10 27 /* call channel_manager$interrupt_later (devx, int_type, int_data) */ 10 28 dcl channel_manager$interrupt_later entry (fixed bin, fixed bin, bit (72) aligned); 10 29 10 30 /* call channel_manager$queued_interrupt (devx, int_type, int_data) */ 10 31 dcl channel_manager$queued_interrupt entry (fixed bin, fixed bin, bit (72) aligned); 10 32 10 33 10 34 /* END INCLUDE FILE ... channel_manager_dcls.incl.pl1 */ 1599 1600 11 1 /* BEGIN INCLUDE FILE ... mcs_interrupt_info.incl.pl1 */ 11 2 11 3 /* Defines constants and structures used by MCS interrupt handlers */ 11 4 11 5 /* Created 08/21/78 by Robert Coren */ 11 6 /* Echo negotiation types added sometime by Bernie Greenberg */ 11 7 /* TIMER and USER_INTERRUPT added in spring of 1982 by Olin Sibert */ 11 8 /* MASKED type added June 23, 1982, by Robert Coren */ 11 9 11 10 dcl DIALUP fixed bin int static options (constant) init (1); 11 11 dcl HANGUP fixed bin int static options (constant) init (2); 11 12 dcl CRASH fixed bin int static options (constant) init (3); 11 13 dcl SEND_OUTPUT fixed bin int static options (constant) init (4); 11 14 dcl INPUT_AVAILABLE fixed bin int static options (constant) init (5); 11 15 dcl ACCEPT_INPUT fixed bin int static options (constant) init (6); 11 16 dcl INPUT_REJECTED fixed bin int static options (constant) init (7); 11 17 dcl QUIT fixed bin int static options (constant) init (8); 11 18 dcl LINE_STATUS fixed bin int static options (constant) init (9); 11 19 dcl DIAL_STATUS fixed bin int static options (constant) init (10); 11 20 dcl WRU_TIMEOUT fixed bin int static options (constant) init (11); 11 21 dcl SPACE_AVAILABLE fixed bin int static options (constant) init (12); 11 22 dcl ACKNOWLEDGE_ECHNEGO_INIT fixed bin int static options (constant) init (13); 11 23 dcl ACKNOWLEDGE_ECHNEGO_STOP fixed bin int static options (constant) init (14); 11 24 dcl TIMER fixed bin int static options (constant) init (15); 11 25 dcl USER_INTERRUPT fixed bin int static options (constant) init (16); 11 26 dcl MASKED fixed bin int static options (constant) init (17); 11 27 11 28 dcl interrupt_info bit (72) aligned; 11 29 11 30 dcl 1 dialup_info aligned, /* for use with DIALUP interrupt */ 11 31 2 line_type fixed bin (9) unal uns, 11 32 2 buffer_pad fixed bin (9) unal uns, /* free space multiplexer would like in output bufs */ 11 33 2 baud_rate fixed bin (18) unal uns, 11 34 2 max_buf_size fixed bin (9) unal uns, 11 35 2 receive_mode_device bit (1) unal, /* device must be told to enter receive mode */ 11 36 2 pad bit (26) unal; 11 37 11 38 dcl 1 rtx_info aligned, /* for use with ACCEPT_INPUT interrupt */ 11 39 2 input_chain unaligned, 11 40 3 chain_head bit (18) unaligned, 11 41 3 chain_tail bit (18) unaligned, 11 42 2 input_count fixed bin (18) unal uns, 11 43 2 flags unaligned, 11 44 3 break_char bit (1), /* data contains a break character */ 11 45 3 output_in_fnp bit (1), /* there is output in the FNP */ 11 46 3 output_in_ring_0 bit (1), /* there is output in ring 0 */ 11 47 3 formfeed_present bit (1), /* input contains a formfeed character */ 11 48 3 pad bit (14); 11 49 11 50 dcl 1 timer_info aligned, /* Info supplied with TIMER interrupt */ 11 51 2 id bit (36) aligned, /* ID which was supplied in call to mcs_timer$set */ 11 52 2 subchan_idx fixed bin; /* Index of subchannel on whose behalf timer was set */ 11 53 11 54 /* END INCLUDE FILE ... mcs_interrupt_info.incl.pl1 */ 1601 1602 12 1 /* BEGIN INCLUDE FILE ... line_types.incl.pl1 */ 12 2 12 3 /* Written November 10 1975 by Paul Green */ 12 4 /* Modified October 1978 by Larry Johnson to include line_type_names */ 12 5 /* Modified 12/19/78 by J. Stern to add POLLED_VIP line type */ 12 6 /* Modified 9/27/79 by J. Stern to add X25LAP line type */ 12 7 /* Modified Spring 1981 by Charles Hornig to add HDLC line type */ 12 8 /* Modified May 1981 by Robert Coren to add COLTS line type */ 12 9 /* Modified September 1984 by Robert Coren to correctly count VIP as a synchronous line type */ 12 10 12 11 12 12 /****^ HISTORY COMMENTS: 12 13* 1) change(86-02-25,Negaret), approve(87-07-13,MCR7679), 12 14* audit(87-07-16,Brunelle), install(87-08-04,MR12.1-1056): 12 15* Add a DSA line type. 12 16* 2) change(87-03-17,Beattie), approve(87-07-13,MCR7656), 12 17* audit(87-07-16,Brunelle), install(87-08-04,MR12.1-1056): 12 18* Add HASP_OPR to identify HASP workstation consoles with login service. 12 19* END HISTORY COMMENTS */ 12 20 12 21 12 22 declare (LINE_MC initial (-2), 12 23 LINE_TELNET initial (-1), 12 24 LINE_UNKNOWN initial (0), 12 25 LINE_ASCII initial (1), 12 26 LINE_1050 initial (2), 12 27 LINE_2741 initial (3), 12 28 LINE_ARDS initial (4), 12 29 LINE_SYNCH initial (5), 12 30 LINE_G115 initial (6), 12 31 LINE_BSC initial (7), 12 32 LINE_ETX initial (8), 12 33 LINE_VIP initial (9), 12 34 LINE_ASYNC1 initial (10), 12 35 LINE_ASYNC2 initial (11), 12 36 LINE_ASYNC3 initial (12), 12 37 LINE_SYNC1 initial (13), 12 38 LINE_SYNC2 initial (14), 12 39 LINE_SYNC3 initial (15), 12 40 LINE_POLLED_VIP initial (16), 12 41 LINE_X25LAP initial (17), 12 42 LINE_HDLC initial (18), 12 43 LINE_COLTS initial (19), 12 44 LINE_DSA initial (20), 12 45 LINE_HASP_OPR initial (21) 12 46 ) fixed bin internal static options (constant); 12 47 12 48 dcl max_line_type fixed bin int static options (constant) init (21); 12 49 12 50 declare n_sync_line_types fixed bin int static options (constant) init (10); 12 51 12 52 declare sync_line_type (10) fixed bin int static options (constant) init (5, 6, 7, 9, 13, 14, 15, 16, 17, 18); 12 53 12 54 dcl line_types (-2:21) char (16) int static options (constant) init ( 12 55 "MC", /* -2 */ 12 56 "TELNET", /* -1 */ 12 57 "none", /* 0 */ 12 58 "ASCII", /* 1 */ 12 59 "1050", /* 2 */ 12 60 "2741", /* 3 */ 12 61 "ARDS", /* 4 */ 12 62 "Sync", /* 5 */ 12 63 "G115", /* 6 */ 12 64 "BSC", /* 7 */ 12 65 "202ETX", /* 8 */ 12 66 "VIP", /* 9 */ 12 67 "ASYNC1", /* 10 */ 12 68 "ASYNC2", /* 11 */ 12 69 "ASYNC3", /* 12 */ 12 70 "SYNC1", /* 13 */ 12 71 "SYNC2", /* 14 */ 12 72 "SYNC3", /* 15 */ 12 73 "POLLED_VIP", /* 16 */ 12 74 "X25LAP", /* 17 */ 12 75 "HDLC", /* 18 */ 12 76 "COLTS", /* 19 */ 12 77 "DSA", /* 20 */ 12 78 "HASP_OPR"); /* 21 */ 12 79 12 80 /* END INCLUDE FILE ... line_types.incl.pl1 */ 1603 1604 13 1 /* --------------- BEGIN include file syserr_codes.incl.pl1 --------------- */ 13 2 13 3 /* THIS INCLUDE FILE IS OBSOLETE. USE syserr_constants include files instead. 13 4*This include file is surrently used only by x25_mpx.pl1. There is a conflict 13 5*in names between syserr_constants.incl.pl1 and one of the communications 13 6*include files (i.e. CRASH for a mpx rather than the system). That include 13 7*file and syserr_constants should be changed to use more meaningful names. */ 13 8 13 9 /* This include file contains action codes for calling syserr, 13 10* admin_gate_$syserr, and friends. 13 11* Written 01/09/79 by C. D. Tavares after pulling out the source for 13 12* syserr_real for the seventh time. */ 13 13 13 14 dcl (Write_on_console initial (0), 13 15 Write_and_crash_system initial (1), 13 16 Write_with_alarm_and_terminate initial (2), 13 17 Write_with_alarm initial (3), 13 18 Log_message initial (4), 13 19 Log_message_or_discard initial (5)) fixed bin static options (constant); 13 20 13 21 /* ---------------- END include file syserr_codes.incl.pl1 ---------------- */ 13 22 1605 1606 14 1 /* START OF: response_transitions.incl.pl1 * * * * * * * * * * * * * * * * */ 14 2 14 3 /* Transition identifiers for metering response time 14 4* 14 5* Written April 1981 by J. Bongiovanni */ 14 6 14 7 dcl (AWARD_ELIGIBILITY init(1), 14 8 CALL_RING_0_TTY init (2), 14 9 RETURN_RING_0_TTY init (3), 14 10 BLOCK_PROCESS init (4), 14 11 NON_TTY_WAKEUP init (5), 14 12 TTY_WAKEUP init (6), 14 13 14 14 MAX_TRANSITION init (6)) fixed bin int static options (constant); 14 15 14 16 /* END OF: response_transitions.incl.pl1 * * * * * * * * * * * * * * * * */ 1607 1608 15 1 /* BEGIN INCLUDE FILE ... mcs_timer_dcls.incl.pl1 ... W. Olin Sibert ... 24 March 1982 */ 15 2 /* Declarations for normally called entries in mcs_timer */ 15 3 15 4 declare mcs_timer$set entry (fixed bin, fixed bin, fixed bin (71), bit (36) aligned); 15 5 declare mcs_timer$change entry (fixed bin, fixed bin, fixed bin (71), bit (36) aligned); 15 6 declare mcs_timer$reset entry (fixed bin, fixed bin, bit (36) aligned); 15 7 declare mcs_timer$reset_all entry (fixed bin); 15 8 15 9 /* END INCLUDE FILE ... mcs_timer_dcls.incl.pl1 */ 1609 1610 16 1 /* BEGIN dn355_data.incl.pl1 */ 16 2 16 3 16 4 16 5 /****^ HISTORY COMMENTS: 16 6* 1) change(88-06-15,Berno), approve(88-07-13,MCR7928), 16 7* audit(88-06-15,Parisek), install(88-07-19,MR12.2-1061): 16 8* Add data needed for the uncp multiplexer (DSA gateway) interface 16 9* implementation. 16 10* 2) change(89-03-20,Parisek), approve(89-06-06,MCR8110), 16 11* audit(89-10-09,Farley), install(89-10-25,MR12.3-1100): 16 12* Add support of protocol mpx. 16 13* END HISTORY COMMENTS */ 16 14 16 15 16 16 /* Date Last Modified and Reason 16 17* 16 18* Created 07/25/74 by R. B. Snyder for new ttydim. 16 19* Modified 06/23/77 by J. Stern to add channel_work_reqd and cwork_count 16 20* Modified 08/14/78 by Robert Coren to remove devx_tab and invent PCBs 16 21* Modified 79 May 14 by Art Beattie to add fnp_mem_size 16 22* Modified December 1979 by Robert Coren to add FNP queue lock 16 23* Modified January 1980 by Larry Johnson to increase max number of FNPs to 8 16 24* Modified 02/12/80 by Robert Coren to add dcw_list_array_ptr 16 25* Modified 03/06/80 by Robert Coren to add some metering info 16 26* Modified 12/10/80 by Robert Coren to add get_meters_waiting flag 16 27* Modified 83-12-16 BIM to use a chanid instead of iom/channel fb's. 16 28* Modified 1984-07-26 BIM for paged iom. 16 29* Modified in September 1985 for the DN7100 version interim. 16 30**/ 16 31 16 32 /* LOCKING RULES: A fnp is locked by its LCTE unless its LCTE is uninitialized. 16 33* In that case, the configuration_lock must be held. 16 34* if tty_lock$lock_lcte returns io_no_permission, then the caller must 16 35* lock$lock_fast the configuration lock and retry the LCTE lock. If 16 36* the lcte is now initialized, too bad. Otherwise, the config lock protects. 16 37* 16 38* Configuration locking is interesting to init_multiplexer and 16 39* all of fnp t&d and reconfiguration. The guts of the multiplexer 16 40* pay no attention to it. Thus, if the LCTE can be locked, it MUST be 16 41* locked before changing the io_manager_assigned flag. */ 16 42 16 43 /* format: style4,delnl,insnl,^ifthendo */ 16 44 16 45 dcl max_no_355s fixed bin int static init (8) options (constant); 16 46 /* max no of 355s we can handle (arbitrary) */ 16 47 dcl dn355_data$ external fixed bin; 16 48 16 49 dcl infop pointer; 16 50 dcl fnpp ptr; 16 51 16 52 dcl 1 datanet_info aligned based (infop), 16 53 2 configuration_lock aligned, 16 54 3 pid bit (36) aligned, 16 55 3 event bit (36) aligned, 16 56 3 flags aligned, 16 57 4 notify_sw bit (1) unaligned, 16 58 4 pad bit (35) aligned, 16 59 2 no_of_355s fixed bin, /* no. of FNP's */ 16 60 2 trace bit (1) aligned, /* watch events on console */ 16 61 2 debug_stop bit (1) aligned, /* crash on errors */ 16 62 2 uncp_bufp ptr, /* pointer to the circular buffer */ 16 63 2 protocol_datap ptr, /* pointer to protocol_mpx data */ 16 64 2 pad1 (6) bit (36) aligned, 16 65 2 per_datanet (max_no_355s) aligned like fnp_info; /* data per datanet */ 16 66 16 67 dcl 1 fnp_info aligned based (fnpp), /* structure for each FNP */ 16 68 2 mbx_pt pointer, /* pointer to mailbox NULL if not in config */ 16 69 2 pcb_array_ptr pointer, /* pointer to array of physical channel blocks */ 16 70 2 dcw_list_array_ptr pointer, /* pointer to array of space reserved for output DCW lists */ 16 71 2 no_of_channels fixed bin, /* number of channels on this FNP */ 16 72 2 fnp_id, 16 73 3 fnp_tag char (1) unaligned, /* letter identifying FNP */ 16 74 3 fnp_number fixed bin (9) unsigned unaligned, /* sequence number of FNP */ 16 75 3 padc bit (18) unaligned, 16 76 2 io_chanid char (8) aligned, 16 77 2 io_manager_chx fixed bin (35), /* devx for DIA on iom */ 16 78 2 lsla_idx (0:5) fixed bin aligned, /* index into PCB array for lsla lines */ 16 79 2 hsla_idx (0:2) fixed bin aligned, /* index into PCB array for hsla lines */ 16 80 2 count fixed bin, /* number of items in delay queue */ 16 81 2 cur_ptr fixed bin, /* offset in tty_buf of next delay queue element */ 16 82 2 last_ptr fixed bin, /* offset in tty_buf of last delay queue element */ 16 83 2 bleft_355 fixed bin, /* number of free buffers in this 355 */ 16 84 2 flags, 16 85 3 work_reqd bit (1) unaligned, /* mailbox messages queued up */ 16 86 3 bootloading bit (1) unaligned, /* currently being bootloaded */ 16 87 3 running bit (1) unaligned, /* this FNP is running */ 16 88 3 wired bit (1) unaligned, /* bootload buffer is wired */ 16 89 3 dump_patch_in_progress bit (1) unaligned, /* a dump or patch order is in progress */ 16 90 3 level_3_pending bit (1) unaligned, /* level 3 interrupt pending */ 16 91 3 level_7_pending bit (1) unaligned, /* level 7 interrupt pending */ 16 92 3 dump_patch_disabled bit (1) unaligned, /* dump & patch orders disabled because of timeout */ 16 93 3 t_and_d_in_progress bit (1) unaligned, /* T & D using FNP */ 16 94 3 t_and_d_lev_3_occurred bit (1) unaligned, /* A level 3 occurred */ 16 95 3 t_and_d_lev_7_occurred bit (1) unaligned, 16 96 3 t_and_d_notify_requested bit (1) unaligned, 16 97 3 t_and_d_assigned bit (1) unaligned, /* AS has given fnp to process */ 16 98 3 get_meters_waiting bit (1) unaligned, /* waiting for meter copy to complete */ 16 99 3 padb bit (7) unaligned, 16 100 3 active_dial unaligned, 16 101 4 active_bit (15) bit (1) unaligned, /* ON if the process is active */ 16 102 2 lcte_ptr ptr, /* pointer to this FNP's LCT entry */ 16 103 2 astep ptr, /* pointer to aste of wired bootload buffer */ 16 104 2 boot_ev_chan fixed bin (71), /* event channel over which to signal bootload completion */ 16 105 2 boot_process_id bit (36), /* process that initiated bootload */ 16 106 2 version char (4), /* version id of core image */ 16 107 2 fnp_mem_size fixed bin (18) unsigned, /* memory size of this FNP in 18-bit words */ 16 108 2 queue_lock bit (36) aligned, /* lock for interrupt queue */ 16 109 2 dump_patch_lock bit (36), /* lock for fnp_dump or _patch operation */ 16 110 2 q_entries_made fixed bin (35), /* count of delay queue entries made */ 16 111 2 input_reject_count fixed bin, /* number of times input rejected */ 16 112 2 processed_from_q fixed bin (35), /* number of interrupts processed from queue */ 16 113 2 fnp_channel_locked fixed bin (35), /* number of times dn355 found per-FNP lock locked */ 16 114 2 input_data_transactions fixed bin (35), /* number of mailbox transactions for input */ 16 115 2 output_data_transactions fixed bin (35), /* number of mailbox transactions for output */ 16 116 2 input_control_transactions fixed bin (35), /* number of mailbox transactions for inbound control info */ 16 117 2 output_control_transactions fixed bin (35), /* number of mailbox transactions for outbound control info */ 16 118 2 cumulative_mbx_in_use fixed bin (35), /* cumulative count of number of outbound mailboxes in use */ 16 119 2 max_mbx_in_use fixed bin, /* maximum number of mailboxes in use at any given time */ 16 120 2 mbx_in_use_updated fixed bin (35), /* number of increments to cumulative_mbx_in_use */ 16 121 2 mbx_unavailable fixed bin (35), /* number of times had to queue mailbox transaction because none available */ 16 122 2 free_size fixed bin (35), /* cumulative amount of bleft_355 */ 16 123 2 free_count fixed bin, /* number of adds to above */ 16 124 2 fnp_space_restricted_output fixed bin (35), /* number of times available FNP space restricted amount of output sent */ 16 125 2 tandd_pcbx fixed bin, /* index of PCB for COLTS channel */ 16 126 2 n_pages_wired fixed bin, /* pages wired for loading */ 16 127 2 config_flags aligned, 16 128 3 available bit (1) unaligned, /* reconfig says "yes" */ 16 129 3 io_manager_assigned bit (1) unaligned, /* We have channel assigned to us */ 16 130 3 pad bit (34) unaligned, 16 131 2 uncp_pcbx1 fixed bin (17) unaligned, /* For the DN7100 */ 16 132 2 uncp_pcbx2 fixed bin (17) unaligned, /* For the DN7100 */ 16 133 2 ptx fixed bin, /* page table index, used only at bootload */ 16 134 2 ptp pointer unaligned; /* page table for this FNP */ 16 135 16 136 /**** The following named constants are used to lay out the 16 137* iom page tables. Each FNP has to have its own page 16 138* table because there is not enough room to have eight different 16 139* bootload images of 32 K and > 64 K of tty_buf 16 140* 16 141* THE MAX TTY BUF LENGTH IS 192 K words. We could have another 16 K 16 142* easily, and then after that it would get hard. */ 16 143 16 144 /**** The layout 16 145* 16 146* Page I/O address Memory address Comments 16 147* ---- ------ -------------- -------- 16 148* 0 0 xxxxxx invalid PTW 16 149* 1 2000 2000 write-enabled (mailbox) 16 150* 2 4000 4000 write-enabled (mailbox) 16 151* 3 6000 6000 write-enabled (mailbox) 16 152* 4 10000 as needed bootload image segment page 0 16 153* .... .... .... .... 16 154* 35 110000 as needed bootload image segment page 31 16 155* 36 112000 xxxxxx invalid PTW 16 156* ... .... .... .... 16 157* 63 160000 .... invalid PTW 16 158* 64 200000 as needed tty_buf page 0 16 159* ... .... .... .... 16 160* 127 260000 as needed tty_buf page 63 16 161* 255 ...... ..... tty_buf page 191 16 162**/ 16 163 16 164 /**** We assume that the page table starts at all zeros. */ 16 165 16 166 declare FIRST_BOOTLOAD_PAGEX fixed bin init (4) int static options (constant); 16 167 declare FIRST_TTY_BUF_PAGEX fixed bin init (64) int static options (constant); 16 168 16 169 /* End include file dn355_data.incl.pl1 */ 1611 1612 1613 end protocol_mpx; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0804.3 protocol_mpx.pl1 >spec>install>1111>protocol_mpx.pl1 1583 1 10/26/89 2011.9 protocol_data.incl.pl1 >ldd>include>protocol_data.incl.pl1 1585 2 11/09/89 2002.4 protocol_infos.incl.pl1 >ldd>include>protocol_infos.incl.pl1 1587 3 10/26/89 2011.9 protocols.incl.pl1 >ldd>include>protocols.incl.pl1 1589 4 10/26/89 2011.9 multiplexer_types.incl.pl1 >ldd>include>multiplexer_types.incl.pl1 1591 5 01/06/85 1422.1 tty_buf.incl.pl1 >ldd>include>tty_buf.incl.pl1 5-152 6 01/06/85 1422.1 hc_fast_lock.incl.pl1 >ldd>include>hc_fast_lock.incl.pl1 1593 7 07/21/88 2036.0 tty_buffer_block.incl.pl1 >ldd>include>tty_buffer_block.incl.pl1 1595 8 06/18/81 0900.8 tty_space_man_dcls.incl.pl1 >ldd>include>tty_space_man_dcls.incl.pl1 1597 9 11/08/82 1005.8 lct.incl.pl1 >ldd>include>lct.incl.pl1 1599 10 05/06/80 0958.2 channel_manager_dcls.incl.pl1 >ldd>include>channel_manager_dcls.incl.pl1 1601 11 10/20/82 0938.6 mcs_interrupt_info.incl.pl1 >ldd>include>mcs_interrupt_info.incl.pl1 1603 12 08/06/87 0913.4 line_types.incl.pl1 >ldd>include>line_types.incl.pl1 1605 13 03/15/85 0953.1 syserr_codes.incl.pl1 >ldd>include>syserr_codes.incl.pl1 1607 14 06/29/81 2258.5 response_transitions.incl.pl1 >ldd>include>response_transitions.incl.pl1 1609 15 11/08/82 1005.8 mcs_timer_dcls.incl.pl1 >ldd>include>mcs_timer_dcls.incl.pl1 1611 16 10/26/89 2011.9 dn355_data.incl.pl1 >ldd>include>dn355_data.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. ACCEPT_INPUT constant fixed bin(17,0) initial dcl 11-15 ref 1045 CON_IND_info based structure level 1 dcl 130 CON_REQ_info 000227 automatic structure level 1 dcl 110 set ref 474 474 CRASH constant fixed bin(17,0) initial dcl 11-12 ref 992 DIAG_71 constant fixed bin(17,0) initial dcl 170 ref 927 1442 DIALED constant fixed bin(17,0) initial dcl 1-81 ref 499 513 541 788 981 DIALING constant fixed bin(17,0) initial dcl 1-81 ref 475 488 770 962 972 1434 DIALUP constant fixed bin(17,0) initial dcl 11-10 ref 902 DIALUP_info 000326 automatic structure level 1 dcl 2-29 set ref 904* DIAL_STATUS constant fixed bin(17,0) initial dcl 11-19 ref 992 HANGUP constant fixed bin(17,0) initial dcl 11-11 ref 992 HUNGUP constant fixed bin(17,0) initial dcl 1-81 ref 196 216 249 741 744 905 995 1002 1023 1133 INACTIVE constant fixed bin(17,0) initial dcl 1-81 ref 240 304 INPUT 000116 constant bit(1) initial packed unaligned dcl 8-20 set ref 847* 864* 917* 1084* 1295* LINE_STATUS constant fixed bin(17,0) initial dcl 11-18 ref 1113 LONGEST_POSSIBLE_STRING constant fixed bin(17,0) initial dcl 171 ref 597 1579 Log_message 000010 constant fixed bin(17,0) initial dcl 13-14 set ref 293* 310* 326* 988* 1153* 1416* 1439* MILLISECONDS_2 000074 constant fixed bin(21,0) initial dcl 173 ref 1017 NCONCONF constant fixed bin(17,0) initial dcl 2-81 ref 783 979 NCONIND constant fixed bin(17,0) initial dcl 2-80 ref 768 955 NCON_IND_info 000330 automatic structure level 1 dcl 2-40 set ref 908* NCON_REQ_info based structure level 1 dcl 2-33 NDISIND constant fixed bin(17,0) initial dcl 2-85 ref 1000 NDIS_IND_REASON based structure level 1 dcl 2-47 NDTIND constant fixed bin(17,0) initial dcl 2-82 ref 753 786 1103 NDTRDYIND constant fixed bin(17,0) initial dcl 2-83 ref 1035 1144 NRESETIND constant fixed bin(17,0) initial dcl 2-84 ref 1118 1368 N_I_i based structure level 1 dcl 111 ref 908 OUTPUT 000115 constant bit(1) initial packed unaligned dcl 8-21 set ref 623* 645* 687* 1298* 1365* 1379* PROTOCOL_MPX constant fixed bin(17,0) initial dcl 4-16 ref 1181 SEND_OUTPUT constant fixed bin(17,0) initial dcl 11-13 ref 1023 SIZE16 constant fixed bin(17,0) initial dcl 175 ref 577 610 618 676 681 SIZE4 constant fixed bin(17,0) initial dcl 174 ref 588 597 614 649 678 1576 SPACE_AVAILABLE constant fixed bin(17,0) initial dcl 11-21 ref 1137 STANDARD_SERVICE 000075 constant char(16) initial packed unaligned dcl 135 ref 472 TIMER constant fixed bin(17,0) initial dcl 11-24 ref 1130 USER_INTERRUPT constant fixed bin(17,0) initial dcl 11-25 ref 970 WAKEUP_CODE_0 constant fixed bin(17,0) initial dcl 176 ref 985 1039 1107 1122 1148 1414 WAKEUP_CODE_100 constant fixed bin(17,0) initial dcl 178 ref 985 1039 1107 1122 1148 1414 WAKEUP_CODE_5 constant fixed bin(17,0) initial dcl 177 ref 985 1039 1107 1122 1148 1414 a_argptr parameter pointer dcl 51 ref 258 267 a_bytes_processed parameter fixed bin(21,0) dcl 65 set ref 504 509* 531 537* 729* 750 756 763* 880* a_call_data parameter varying char(48) dcl 58 ref 351 353 402 404 433 440 a_code parameter fixed bin(35,0) dcl 69 set ref 188 191* 198* 202 206* 211 218* 222 228* 233 254* 258 269* 294* 311* 316 319* 334 343* 348* 351 356* 362* 376* 385 393* 396* 397* 402 406* 409* 419* 422* 433 451* 483 504 531 736 750 756 1193* a_data_base_ptr parameter pointer dcl 52 set ref 188 192 202 204 211 213 222 225 233 235 258 268* 306* 316 321 331* 888 893 a_event parameter fixed bin(71,0) dcl 54 ref 334 336 351 354 433 437 483 494 a_first_entry parameter fixed bin(17,0) dcl 64 set ref 504 507 730* a_from_na parameter varying char(15) dcl 55 ref 433 438 a_info parameter bit(72) dcl 68 ref 888 895 a_int_type parameter fixed bin(17,0) dcl 62 ref 756 759 a_offset parameter fixed bin(21,0) dcl 66 set ref 504 508 531 535 728* a_order parameter char packed unaligned dcl 59 ref 222 226 233 236 a_partial parameter bit(1) packed unaligned dcl 53 ref 351 355 a_pinfop parameter pointer dcl 61 set ref 222 227 233 237 504 506 736 743* 750 756 761 a_protocol_id parameter fixed bin(17,0) dcl 67 ref 334 337 385 387 a_scp parameter pointer dcl 60 set ref 531 534 732* a_target_offset parameter fixed bin(21,0) dcl 1528 in procedure "copy_from_us_to_user" ref 1513 1539 a_target_offset parameter fixed bin(17,0) dcl 1248 in procedure "copy_chars" ref 1234 1258 a_target_offset parameter fixed bin(17,0) dcl 1470 in procedure "copy_from_user_to_us" ref 1455 1480 a_to_na parameter varying char(15) dcl 56 ref 433 439 a_type parameter fixed bin(17,0) dcl 63 ref 888 894 a_user_index parameter fixed bin(17,0) dcl 57 ref 433 436 483 493 addr parameter varying char(15) dcl 1201 in procedure "get_channel" ref 1198 1204 1204 addr builtin function dcl 182 in procedure "protocol_mpx" ref 243 243 262 264 299 322 339 365 389 412 442 444 454 474 474 898 899 908 954 955 956 957 959 959 968 968 978 979 980 998 999 1000 1001 1034 1035 1036 1075 1076 1102 1103 1104 1117 1118 1119 1143 1144 1145 1164 1167 1180 1265 1265 1271 1271 1279 1279 1367 1368 1433 1446 1446 1483 1488 1494 1502 1542 1547 1553 1561 bin builtin function dcl 182 ref 628 638 696 857 1048 1052 1059 1358 1361 bleft 3 based fixed bin(18,0) level 2 dcl 5-35 ref 584 blockp 000372 automatic pointer dcl 7-19 set ref 556* 574* 577 579 581* 581 605* 606 606 610 611 796* 796* 800* 801 801 814* 860* 860* 861 861 862 871* 907* 908 917* 1224* 1224 1225 1227 1229* 1230 1230* 1330* 1332 1332 1334* 1334 1336 1338 1339 1352* 1353 1354* 1354 1357 1358 break 0(20) based bit(1) level 3 in structure "buffer" packed packed unaligned dcl 7-28 in procedure "protocol_mpx" set ref 606 712* 843* 1060 1079* 1079 1080 1225 1332 1336 break 000160 automatic bit(1) packed unaligned dcl 87 in procedure "protocol_mpx" set ref 528* 557* 600* 710 817* 818 823* 843 872* 875 break_char 1(18) 000406 automatic bit(1) level 3 packed packed unaligned dcl 11-38 set ref 1100 break_flag parameter bit(1) packed unaligned dcl 1218 set ref 1212 1223* 1225* 1227 buf_size 000165 automatic fixed bin(17,0) dcl 89 set ref 610* 614 618* 618 621 623* 672* 676* 678 681* 681 687* buffer based structure level 1 dcl 7-28 buffer_pad 0(09) 000404 automatic fixed bin(9,0) level 2 in structure "dialup_info" packed packed unsigned unaligned dcl 11-30 in procedure "protocol_mpx" set ref 910 975 buffer_pad 70 based fixed bin(9,0) level 2 in structure "channel" unsigned dcl 1-46 in procedure "protocol_mpx" set ref 588 614 649 678 910* 975* 1315* 1576 bytes_processed 000130 automatic fixed bin(21,0) dcl 76 set ref 563* 655* 655 694* 694 729 763* 841* 841 880 call_data 000113 automatic varying char(48) dcl 75 in procedure "protocol_mpx" set ref 353* 358 360 368 380 404* 407 414 440* 473 call_data 350 based varying char(48) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 279* call_data 40 based varying char(48) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 774 914* 921 923 934 934 937 1312* call_datas 24 based structure array level 3 dcl 1-25 cause based fixed bin(8,0) level 2 packed packed unaligned dcl 131 set ref 926* 1441* ceil builtin function dcl 182 ref 1577 chain_head 000406 automatic bit(18) level 3 packed packed unaligned dcl 11-38 set ref 1048 1059 chain_tail 0(18) 000406 automatic bit(18) level 3 packed packed unaligned dcl 11-38 set ref 1052 channel based structure level 1 dcl 1-46 set ref 330* channel_manager$control 000074 constant entry external dcl 10-13 ref 196 216 243 474 496 743 959 968 985 1039 1107 1122 1133 1148 1446 channel_manager$write 000072 constant entry external dcl 10-10 ref 1340 channel_ptr 000322 automatic pointer dcl 1-44 set ref 192* 193 195 196 204* 205 213* 215 216 225* 235* 239 240 240 246 247 248 249 299* 300 302 303 304 305 306 321* 324 326 330 454* 455 463 463 464 464 465 466 467 468 468 475 488 493 494 495 499 500 513 541 565 572 574 584 588 588 592 594 603 605 606 606 614 615 630 632 634 634 641 649 651 656 656 657 657 657 668 672 678 697 697 698 698 698 700 700 704 713 713 718 724 725 741 744 770 772 773 774 775 777 783 788 814 815 849 849 858 863 868 871 874 877 879 893* 897 905 910 911 912 912 913 914 915 921 923 934 934 937 962 963 964 965 972 975 976 980 981 982 983 983 988 995 1001 1002 1003 1003 1005 1007 1007 1014 1014 1019 1023 1026 1027 1030 1030 1030 1036 1037 1037 1041 1053 1055 1058 1098 1100 1104 1105 1105 1109 1115 1119 1120 1120 1132 1133 1133 1139 1141 1141 1145 1146 1146 1153 1184* 1185 1185 1185 1295 1295 1295 1298 1298 1298 1301 1301 1301 1301 1303 1303 1304 1304 1305 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1328 1330 1358 1369 1369 1374 1375 1375 1379 1379 1380 1380 1382 1416 1433* 1434 1436 1439 1443 1446 1447 1576 1576 1577 1579 1579 channel_type 2 based fixed bin(8,0) level 2 packed packed unaligned dcl 9-20 ref 1181 channels 310 based structure array level 2 dcl 1-25 set ref 275* 299 454 1433 chars 1 based char(1) array level 2 packed packed unaligned dcl 7-28 set ref 908 1075 1076 1265 1265 1271 1271 1279 1279 1488 1494 1502 1547 1553 1561 chars_in_buf 000176 automatic fixed bin(17,0) dcl 98 set ref 614* 615 615 615 649* 651 678* 679 cleanup 000214 stack reference condition dcl 106 ref 457 486 511 539 739 765 clock builtin function dcl 182 ref 283 1017 code 000211 automatic fixed bin(35,0) dcl 104 set ref 196* 198 216* 218 243* 244 252* 253* 254 458* 459 474* 475 490* 496* 497 543* 550* 567* 743* 747* 778* 780* 882* 885* 1171* 1175* 1176 1191* 1193 1340* 1341 1344* 1350 1377 1436* 1437 1443* 1444 1446* cscp 000152 automatic pointer dcl 83 set ref 561* 654* 693* 721 732 814* 830* 835* 845 852 854 856 857 cur_chain_len 000172 automatic fixed bin(17,0) dcl 94 set ref 571* 578* 578 584 598* 598 685 690* 690 cur_space 000171 automatic fixed bin(17,0) dcl 93 set ref 570* 577* 577 584 data 14 000330 automatic varying char(48) level 2 in structure "NCON_IND_info" dcl 2-40 in procedure "protocol_mpx" set ref 914 data 20 000227 automatic varying char(48) level 2 in structure "CON_REQ_info" dcl 110 in procedure "protocol_mpx" set ref 473* data 14 based varying char(48) level 2 in structure "CON_IND_info" dcl 130 in procedure "protocol_mpx" set ref 774* data_base_ptr 1 based pointer level 2 packed packed unaligned dcl 9-20 ref 1184 data_ptr 2 based pointer array level 3 dcl 2-61 ref 809 1483 1542 datanet_info based structure level 1 dcl 16-52 datas 25 based varying char(48) array level 4 dcl 1-25 set ref 286* 368 370 380* 414 425* 933 934 937 devx 000225 automatic fixed bin(17,0) dcl 108 in procedure "protocol_mpx" set ref 193* 196* 215* 216* 239* 243* 261* 302 303 455* 458* 474* 478 496* 592* 623* 645* 687* 725* 743* 847* 864* 897* 917* 954 959* 968* 978 985* 988* 999 1017* 1034 1039* 1084* 1102 1107* 1117 1122* 1133* 1143 1148* 1153* 1163* 1169 1169 1175* 1180 1295* 1298* 1340* 1343* 1365* 1367 1379* 1404* devx 10 based fixed bin(17,0) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 193 215 239 303* 324* 455 897 1443* 1446* 1447* diag 0(09) based fixed bin(8,0) level 2 packed packed unaligned dcl 131 set ref 927* 1442* dial_info based bit(72) level 2 in structure "CON_IND_info" dcl 130 in procedure "protocol_mpx" set ref 776* dial_info 000330 automatic bit(72) level 2 in structure "NCON_IND_info" dcl 2-40 in procedure "protocol_mpx" set ref 909 dialup_info 000404 automatic structure level 1 dcl 11-30 set ref 909* 974* divide builtin function dcl 182 ref 584 dn355_data$ 000102 external static fixed bin(17,0) dcl 16-47 set ref 262 322 339 365 389 412 444 899 1167 end_chain 000162 automatic bit(1) packed unaligned dcl 87 set ref 575* 576 579* entry 2 based structure array level 2 dcl 2-61 error_table_$action_not_performed 000014 external static fixed bin(35,0) dcl 140 ref 376 419 error_table_$bad_arg 000016 external static fixed bin(35,0) dcl 140 ref 343 362 393 409 550 885 error_table_$buffer_big 000020 external static fixed bin(35,0) dcl 140 ref 567 error_table_$invalid_device 000026 external static fixed bin(35,0) dcl 140 ref 1171 error_table_$invalid_state 000024 external static fixed bin(35,0) dcl 140 ref 252 490 543 747 780 882 error_table_$invalid_write 000030 external static fixed bin(35,0) dcl 140 ref 1394 error_table_$io_no_permission 000022 external static fixed bin(35,0) dcl 140 ref 397 422 1191 error_table_$noalloc 000032 external static fixed bin(35,0) dcl 140 ref 1393 error_table_$resource_unavailable 000034 external static fixed bin(35,0) dcl 140 ref 451 error_table_$undefined_order_request 000036 external static fixed bin(35,0) dcl 140 ref 253 ev_devx based fixed bin(17,0) level 2 packed packed unaligned dcl 2-74 set ref 954* 978* 999* 1034* 1102* 1117* 1143* 1367* ev_type 0(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 2-74 set ref 955* 979* 1000* 1035* 1103* 1118* 1144* 1368* ev_user_index 1 based fixed bin(17,0) level 2 packed packed unaligned dcl 2-74 set ref 956* 980* 1001* 1036* 1104* 1119* 1145* event 000212 automatic fixed bin(71,0) dcl 105 set ref 336* 347 354* 382 437* 464 920* 945* 950* 958* 965 event_id 44 based fixed bin(71,0) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 382* 428* 945 event_id 6 based fixed bin(71,0) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 347* 950 ever_initialized 000010 internal static bit(1) initial packed unaligned dcl 137 set ref 272 288* facilities 365 based varying char(16) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 280* facilities 13 000227 automatic varying char(16) level 2 in structure "CON_REQ_info" dcl 110 in procedure "protocol_mpx" set ref 472* facilities 31 000330 automatic varying char(16) level 2 in structure "NCON_IND_info" dcl 2-40 in procedure "protocol_mpx" set ref 915 facilities 31 based varying char(16) level 2 in structure "CON_IND_info" dcl 130 in procedure "protocol_mpx" set ref 775* facilities 55 based varying char(16) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 775 915* 1313* fblock 62 based fixed bin(17,0) level 2 dcl 1-46 set ref 814 815 849* 858 863* 868 871 1053 1055* 1295 1295 1295 1303* filled 000307 automatic bit(1) packed unaligned dcl 123 set ref 1067* 1068 1080* 1088* flags 0(18) based structure level 2 in structure "buffer" packed packed unaligned dcl 7-28 in procedure "protocol_mpx" set ref 661* 707* 836* flags 1(18) 000406 automatic structure level 2 in structure "rtx_info" packed packed unaligned dcl 11-38 in procedure "protocol_mpx" flags 323 based structure array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" flags 13 based structure level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" fnp_info based structure level 1 dcl 16-67 from_na 000100 automatic varying char(15) dcl 72 set ref 438* 448* hbound builtin function dcl 182 ref 341 358 360 367 391 414 417 923 928 930 hc_fast_lock based structure level 1 dcl 6-10 headp 000520 automatic pointer dcl 1325 in procedure "send_next_nsdu" set ref 1330* 1340* 1348 1352 1361 1365* headp 000202 automatic pointer dcl 99 in procedure "protocol_mpx" set ref 814* 847* 860 864* his_address 2 based varying char(15) level 2 in structure "CON_IND_info" dcl 130 in procedure "protocol_mpx" set ref 773* his_address 2 000330 automatic varying char(15) level 2 in structure "NCON_IND_info" dcl 2-40 in procedure "protocol_mpx" set ref 913 his_network_address 343 based varying char(15) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 278* his_network_address 33 based varying char(15) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 467* 773 913* 1311* i 000606 automatic fixed bin(17,0) dcl 1574 in procedure "compute_max_nsdu_size" set ref 1577* 1579 i 000222 automatic fixed bin(17,0) dcl 107 in procedure "protocol_mpx" set ref 274* 275 276 277 278 279 280* 298* 299* 358* 358* 360 368* 368* 370 370* 370* 374 379 380 381 382 414* 414* 417 422 425 426 427 428 521* 522* 795* 797* 797 798 807* 808 809* 857* 858 860 863 932* 933 934 934 937 937* 943* 943 944 945 1432* 1433* i 000460 automatic fixed bin(17,0) dcl 1201 in procedure "get_channel" set ref 1204* 1204 1204 1204* 1208 ignore_code 000272 automatic fixed bin(35,0) dcl 113 set ref 959* 968* 985* 1039* 1107* 1122* 1133* 1148* in 10 based structure level 3 in structure "lcte" dcl 9-20 in procedure "protocol_mpx" in 2 based structure level 2 in structure "saved_meters" dcl 9-68 in procedure "protocol_mpx" in 30 based structure array level 4 in structure "lct" dcl 9-11 in procedure "protocol_mpx" in_use 323(02) based bit(1) array level 4 in structure "protocol_data" packed packed unaligned dcl 1-25 in procedure "protocol_mpx" set ref 1204 in_use 13(02) based bit(1) level 3 in structure "channel" packed packed unaligned dcl 1-46 in procedure "protocol_mpx" set ref 466* 963* 1301* inchain 000274 automatic fixed bin(18,0) dcl 115 set ref 1048* 1049 1055 info_relp 000326 automatic bit(18) level 2 packed packed unaligned dcl 2-29 set ref 907 infop 000410 automatic pointer dcl 16-49 set ref 262* 263 322* 323 339* 340 365* 366 389* 390 412* 413 444* 445 899* 900 1167* 1168 infos 1(18) based bit(18) level 2 packed packed unaligned dcl 2-74 set ref 957* 998* init_time 2 based fixed bin(71,0) level 2 dcl 1-25 set ref 283* initialized 13 based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 240 300 305* input_chain 000406 automatic structure level 2 packed packed unaligned dcl 11-38 int_type 000273 automatic fixed bin(17,0) dcl 114 set ref 753* 759* 768 783 786 894* 902 970 992 992 992 1023 1045 1113 1130 1137 1153* interrupt_info 000402 automatic bit(72) dcl 11-28 set ref 895* 904 974 998 1047 last_offset 000276 automatic fixed bin(17,0) dcl 117 set ref 1052* 1094* 1098 1098 lastp 000204 automatic pointer dcl 99 set ref 605* 626 626 629 634 638 645* 646* 652* 652 654* 654 660 660 661 662 703 705* 712 layer3_ISO constant fixed bin(17,0) initial dcl 3-18 ref 921 layer3_call_datas 000010 constant varying char(48) initial array dcl 3-24 ref 358 358 360 923 lblock 63 based fixed bin(17,0) level 2 dcl 1-46 set ref 849* 1058 1098* 1303* lbound builtin function dcl 182 ref 341 391 923 lchar 000170 automatic fixed bin(17,0) dcl 92 set ref 611* 615 615 651 lcnt based structure level 1 dcl 9-65 lcnt_ptr 2 based pointer level 2 dcl 9-11 ref 266 1166 lcntp 000400 automatic pointer dcl 9-63 set ref 266* 302 1166* lct based structure level 1 dcl 9-11 lct_ptr 6 based pointer level 2 dcl 5-35 ref 265 443 1165 lcte based structure level 1 dcl 9-20 lcte_array 20 based structure array level 2 dcl 9-11 set ref 1180 lctep 000376 automatic pointer dcl 9-8 set ref 1180* 1181 1184 lctp 000374 automatic pointer dcl 9-7 set ref 265* 266 443* 1165* 1166 1169 1180 length parameter fixed bin(17,0) dcl 1219 in procedure "check_length" set ref 1212 1222* 1229* 1229 length builtin function dcl 182 in procedure "protocol_mpx" ref 921 933 934 length_to_copy 000154 automatic fixed bin(17,0) dcl 84 set ref 599* 600 615 651 659* 659 667* 667 667* 668* 708 710 817* 820 822* 826* 826 826* 829 834* 842 listener_event 16 based fixed bin(71,0) level 2 dcl 1-46 set ref 464* 965* 1007* 1306* listener_proc_id 14 based bit(36) level 2 dcl 1-46 set ref 463* 964* 1005 1007* 1185 1307* listeners 4 based structure array level 2 dcl 1-25 set ref 284* 341 341 391 391 399* 923 923 928 load_proc_id 12 based bit(36) level 2 dcl 1-46 set ref 248* locked 000226 automatic bit(1) packed unaligned dcl 109 set ref 194* 207* 214* 229* 238* 270* 320* 338* 357* 388* 405* 456* 461* 485* 510* 538* 738* 764* 896* 1178* 1402 1405* m 000223 automatic fixed bin(17,0) dcl 107 set ref 668* 669 679 683 933* 934 934 max_buf_size 1 000404 automatic fixed bin(9,0) level 2 in structure "dialup_info" packed packed unsigned unaligned dcl 11-30 in procedure "protocol_mpx" set ref 911 976 max_buf_size 67 based fixed bin(9,0) level 2 in structure "channel" unsigned dcl 1-46 in procedure "protocol_mpx" set ref 584 588 672 911* 976* 1314* 1576 max_buffer_tally 000000 constant fixed bin(17,0) initial array dcl 7-43 ref 800 834 1065 max_chain_len constant fixed bin(17,0) initial dcl 179 ref 584 598 1579 max_channels based fixed bin(17,0) level 2 dcl 1-25 ref 274 291 298 1204 1432 max_chars 000174 automatic fixed bin(17,0) dcl 96 set ref 597* 599 max_chars_in_buf 000175 automatic fixed bin(17,0) dcl 97 set ref 588* 606 615 669 671 1576* 1577 max_no_355s internal static fixed bin(17,0) initial dcl 16-45 ref 16-52 max_no_lctes based fixed bin(17,0) level 2 dcl 9-11 ref 1169 max_nsdu_size 71 based fixed bin(17,0) level 2 dcl 1-46 set ref 565 777 783 1316* 1579* max_packet_size 5 000264 automatic fixed bin(17,0) level 2 in structure "net_infos" dcl 112 in procedure "protocol_mpx" set ref 247 max_packet_size 25 based fixed bin(17,0) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 247* 468 606 657 698 713 912 1305 1577 1579 max_space 000173 automatic fixed bin(17,0) dcl 95 set ref 584* 590 597 max_tally 000306 automatic fixed bin(17,0) dcl 122 set ref 1065* 1073 mbz 000227 automatic fixed bin(35,0) level 2 dcl 110 set ref 470* mcs_timer$reset_all 000100 constant entry external dcl 15-7 ref 324 mcs_timer$set 000076 constant entry external dcl 15-4 ref 1017 meters 26 based structure array level 3 in structure "lct" dcl 9-11 in procedure "protocol_mpx" meters 6 based structure level 2 in structure "lcte" dcl 9-20 in procedure "protocol_mpx" miip 000132 automatic pointer dcl 78 set ref 267* min builtin function dcl 182 ref 584 597 599 651 668 829 834 1579 n 000224 automatic fixed bin(17,0) dcl 107 in procedure "protocol_mpx" set ref 367* 368 370 370 374 651* 652* 654* 655 656 659 660 671* 683* 691* 693* 694 695 697 708 795* 800* 800 806* 808* 808 820 822 829* 830* 834* 835* 837 841 842 852* 855* 856 872* 875 930* 932 n 000500 automatic fixed bin(17,0) dcl 1251 in procedure "copy_chars" set ref 1264* 1265 1265 1266 1270* 1271 1271 1278* 1279 1279 1285 1286 n 000575 automatic fixed bin(17,0) dcl 1532 in procedure "copy_from_us_to_user" set ref 1546* 1547 1547 1548 1552* 1553 1553 1560* 1561 1561 1567 1568 n 000560 automatic fixed bin(17,0) dcl 1472 in procedure "copy_from_user_to_us" set ref 1487* 1488 1488 1489 1493* 1494 1494 1501* 1502 1502 1508 1509 n_channels 1 based fixed bin(17,0) level 2 dcl 1-25 set ref 282* 291 297* 297 325* 325 326 n_chars_in_source_buffer 000503 automatic fixed bin(17,0) dcl 1253 in procedure "copy_chars" set ref 1261* 1262 1268 1270 n_chars_in_source_buffer 000577 automatic fixed bin(17,0) dcl 1533 in procedure "copy_from_us_to_user" set ref 1543* 1544 1550 1552 n_chars_in_source_buffer 000563 automatic fixed bin(21,0) dcl 1474 in procedure "copy_from_user_to_us" set ref 1484* 1485 1491 1493 n_chars_to_copy parameter fixed bin(17,0) dcl 1530 in procedure "copy_from_us_to_user" ref 1513 1541 n_chars_to_copy parameter fixed bin(17,0) dcl 1248 in procedure "copy_chars" ref 1234 1260 n_chars_to_copy parameter fixed bin(17,0) dcl 1470 in procedure "copy_from_user_to_us" ref 1455 1482 n_entries based fixed bin(17,0) level 2 dcl 2-61 ref 515 521 807 1495 1503 name 310 based char(32) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 276* name based char(32) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 302* 326* 1416* 1439* names based char(32) array level 2 packed packed unaligned dcl 9-65 ref 302 nctc 000561 automatic fixed bin(17,0) dcl 1472 in procedure "copy_from_user_to_us" set ref 1482* 1482* 1485 1487 1491 1501* 1509 nctc 000576 automatic fixed bin(17,0) dcl 1532 in procedure "copy_from_us_to_user" set ref 1541* 1541* 1544 1546 1550 1560* 1568 nctc 000501 automatic fixed bin(17,0) dcl 1251 in procedure "copy_chars" set ref 1260* 1260* 1262 1264 1268 1278* 1286 ndis_ind_reason based structure level 1 dcl 131 set ref 959 959 968 968 1446 1446 net_infos 000264 automatic structure level 1 dcl 112 set ref 243 243 network_address 000264 automatic varying char(15) level 2 dcl 112 set ref 246 network_infos based structure level 1 dcl 2-55 new_buf 000210 automatic fixed bin(17,0) dcl 101 set ref 628* 630 696* 700 703 704 new_bufp 000200 automatic pointer dcl 99 set ref 623* 624 626* 628 629 646 685* 687* 688 691* 693* 695 696 705 706 707 new_chars based char packed unaligned dcl 132 set ref 1077* 1077 new_first_tally 000304 automatic fixed bin(17,0) dcl 120 set ref 1071* 1073 1077 1077 1078 new_headp 000300 automatic pointer dcl 118 set ref 1070* 1071 1075 1079 1080 1082 1084* next based fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 7-28 set ref 579 581 638 638 640 641* 662* 703* 706* 801 839 860 861 862* 1082 1093* 1227 1230 1272 1274 1280 1282 1332 1334 1338 1339* 1353 1354 1357* 1554 1556 1562 1564 next_head 000522 automatic fixed bin(17,0) dcl 1326 set ref 1338* 1357 1358 1361* 1374 next_offset 000275 automatic fixed bin(17,0) dcl 116 set ref 1059* 1068 1070 1082* 1093 1094 no_write_code 000011 internal static fixed bin(35,0) dcl 153 set ref 1394* noalloc_code 000012 internal static fixed bin(35,0) dcl 154 set ref 294 311 1341 1393* null builtin function dcl 182 ref 196 196 216 216 268 331 496 496 515 548 624 685 688 721 793 804 809 845 985 985 1039 1039 1107 1107 1122 1122 1133 1133 1148 1148 1272 1280 1348 1554 1562 old_last_tally 000305 automatic fixed bin(17,0) dcl 121 set ref 1063* 1073 1076 1078* 1078 1091 old_tailp 000302 automatic pointer dcl 119 set ref 1058* 1060 1063 1065 1076 1079 1091 1093 order 000134 automatic char(32) packed unaligned dcl 79 set ref 226* 236* 240 orig_buf_size 000167 automatic fixed bin(17,0) dcl 91 set ref 610* 621 649 our_address 7 based varying char(15) level 2 dcl 130 set ref 772* our_network_address 26 based varying char(15) level 2 in structure "channel" dcl 1-46 in procedure "protocol_mpx" set ref 246* 772 our_network_address 336 based varying char(15) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 277* 1204 output_bpart constant fixed bin(18,0) initial dcl 5-19 ref 584 partial 000316 automatic bit(1) packed unaligned dcl 128 in procedure "protocol_mpx" set ref 355* 379 partial 24 based bit(1) array level 4 in structure "protocol_data" packed packed unaligned dcl 1-25 in procedure "protocol_mpx" set ref 379* 426* 934 937 pds$processid 000040 external static bit(36) dcl 157 ref 248 346 381 397 422 463 495 1185 1185 pinfop 000324 automatic pointer dcl 2-27 set ref 227* 237* 506* 515 515 515 521 522 761* 772 773 774 775 776 792 804 807 808 809 829 926 927 959 959 968 968 1441 1442 1446 1446 1483 1483 1484 1495 1503 1542 1542 prevp 000206 automatic pointer dcl 99 set ref 632* 634 638* 638 638 638* 640 641 838* 843 854* 855* 855* proc_id 42 based bit(36) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 381* 422 427* 944 proc_id 4 based bit(36) array level 3 in structure "protocol_data" dcl 1-25 in procedure "protocol_mpx" set ref 346* 397 949 process_id 000315 automatic bit(36) dcl 127 set ref 919* 944* 949* 952 958* 964 protocol_data based structure level 1 dcl 1-25 protocol_data_ptr 000320 automatic pointer dcl 1-22 set ref 263* 274 275 276 277 278 279 280 282 283 284 285 286 291 291 297 297 298 299 323* 325 325 326 340* 341 341 346 347 366* 367 368 370 379 380 381 382 390* 391 391 397 399 413* 414 414 417 422 425 426 427 428 445* 454 900* 923 923 928 930 933 934 934 937 937 944 945 949 950 1168* 1204 1204 1204 1204 1432 1433 protocol_datap 12 based pointer level 2 dcl 16-52 ref 263 323 340 366 390 413 445 900 1168 protocol_event_message 000366 automatic fixed bin(71,0) dcl 2-72 set ref 954 955 956 957 958* 978 979 980 983* 998 999 1000 1001 1003* 1007* 1034 1035 1036 1037* 1102 1103 1104 1105* 1117 1118 1119 1120* 1143 1144 1145 1146* 1367 1368 1369* protocol_id 000166 automatic fixed bin(17,0) dcl 90 set ref 337* 341 341 346 347 387* 391 391 397 399 921* 923* 923* 928 949 950 protocol_msg based structure level 1 packed packed unaligned dcl 2-74 ptr builtin function dcl 182 ref 574 581 605 632 640 801 814 839 861 871 907 1058 1070 1230 1274 1282 1295 1295 1298 1298 1330 1334 1354 1379 1379 1556 1564 pxss$ring_0_wakeup 000046 constant entry external dcl 162 ref 958 983 1003 1007 1037 1105 1120 pxss$unique_ring_0_wakeup 000050 constant entry external dcl 163 ref 1146 1369 pxss_status 000314 automatic fixed bin(35,0) dcl 126 set ref 958* 983* 985 985 985 1003* 1007* 1037* 1039 1039 1039 1105* 1107 1107 1107 1120* 1122 1122 1122 1146* 1148 1148 1148 1414 1414 1414 1416* read_entry 000164 automatic bit(1) packed unaligned dcl 87 set ref 752* 760* 790 827 843 rel builtin function dcl 182 ref 628 638 696 796 857 1358 1361 rest parameter fixed bin(21,0) dcl 102 set ref 750 756 763* 777* 783* 873* 875* rflag 13(05) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 500* 874* 877* 879* 982* 1100 1109* 1301* rtx_info 000406 automatic structure level 1 dcl 11-38 set ref 1047* sci 000155 automatic fixed bin(21,0) dcl 85 set ref 508* 515 515 524 535* 554 554 558 652* 654* 691* 693* 728 825* 830* 835* 852 855* scidx 000156 automatic fixed bin(17,0) dcl 86 set ref 507* 515 515 515 521 652* 691* 714* 721 730 scl 000150 automatic fixed bin(17,0) dcl 82 set ref 520* 522* 522 524* 524 525 536* 557* 558* 558 559 565 599 600 scp 000144 automatic pointer dcl 80 set ref 534* 548 554 556 561 scx 000131 automatic fixed bin(17,0) dcl 77 set ref 448* 449 454 send_output 13(03) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 592 718 725 1026* 1030 1141 1301* 1328 1382* size 4 based fixed bin(21,0) array level 3 unsigned dcl 2-61 ref 515 522 808 829 1483 1484 1542 size_code 0(24) based fixed bin(3,0) level 2 packed packed unsigned unaligned dcl 7-28 ref 577 610 800 834 1065 source_chars based char packed unaligned dcl 1535 in procedure "copy_from_us_to_user" ref 1547 1553 1561 source_chars based char packed unaligned dcl 1477 in procedure "copy_from_user_to_us" ref 1488 1494 1502 source_chars based char packed unaligned dcl 1255 in procedure "copy_chars" ref 1265 1271 1279 source_chars_p 000556 automatic pointer dcl 1467 set ref 1483* 1488 1494 1502 source_index parameter fixed bin(17,0) dcl 1470 set ref 1455 1483 1483 1484 1495 1495* 1497* 1497 1503 1503* 1505* 1505 source_offset parameter fixed bin(21,0) dcl 1528 in procedure "copy_from_us_to_user" set ref 1513 1543 1547 1548* 1548 1553 1557* 1561 1565* source_offset parameter fixed bin(21,0) dcl 1250 in procedure "copy_chars" set ref 1234 1261 1265 1266* 1266 1271 1275* 1279 1283* source_offset parameter fixed bin(21,0) dcl 1469 in procedure "copy_from_user_to_us" set ref 1455 1483 1484 1489* 1489 1498* 1506* source_ptr parameter pointer dcl 1246 in procedure "copy_chars" set ref 1234 1261 1265 1271 1272 1272* 1274* 1274 1274 1279 1280 1280* 1282* 1282 1282 source_ptr parameter pointer dcl 1526 in procedure "copy_from_us_to_user" set ref 1513 1543 1547 1553 1554 1554* 1556* 1556 1556 1561 1562 1562* 1564* 1564 1564 source_ptr 000310 automatic pointer dcl 124 in procedure "protocol_mpx" set ref 1075* 1077 space_left_in_packet 66 based fixed bin(17,0) level 2 dcl 1-46 set ref 468* 606 615 651 656* 656 657 657* 668 697* 697 698 698* 713* 912* 1305* special_listeners 24 based structure array level 2 dcl 1-25 set ref 285* 367 414 417 930 started 323(01) based bit(1) array level 4 in structure "protocol_data" packed packed unaligned dcl 1-25 in procedure "protocol_mpx" set ref 1204 started 13(01) based bit(1) level 3 in structure "channel" packed packed unaligned dcl 1-46 in procedure "protocol_mpx" set ref 195* 205* 1014 1133 state 11 based fixed bin(17,0) level 2 dcl 1-46 set ref 196 216 240 249* 304* 475* 488 499* 513 541 741 744* 770 788 905 962* 972 981* 988* 995 1002* 1023 1133 1153* 1434 stop 000161 automatic bit(1) packed unaligned dcl 87 in procedure "protocol_mpx" set ref 612* 613 615* 675* 677 679* 931* 932 934* 937* 941 stop 000470 automatic bit(1) packed unaligned dcl 1220 in procedure "check_length" set ref 1223* 1224 1227* string builtin function dcl 182 set ref 661* 707* 836* substr builtin function dcl 182 ref 934 998 1483 1542 syserr 000054 constant entry external dcl 167 ref 293 310 326 988 1153 1416 1439 tally 0(27) based fixed bin(9,0) level 2 packed packed unsigned unaligned dcl 7-28 set ref 554 606 611 626 629* 629 652 654 660* 660 695* 837* 852 856* 1063 1071 1091* 1229 1261 1543 target_chars based char packed unaligned dcl 1478 in procedure "copy_from_user_to_us" set ref 1488* 1494* 1502* target_chars based char packed unaligned dcl 1256 in procedure "copy_chars" set ref 1265* 1271* 1279* target_chars based char packed unaligned dcl 1537 in procedure "copy_from_us_to_user" set ref 1547* 1553* 1561* target_index parameter fixed bin(17,0) dcl 1530 ref 1513 1542 1542 target_offset 000502 automatic fixed bin(17,0) dcl 1251 in procedure "copy_chars" set ref 1258* 1265 1271 1279 1285* 1285 target_offset 000574 automatic fixed bin(21,0) dcl 1528 in procedure "copy_from_us_to_user" set ref 1539* 1542 1567* 1567 target_offset 000562 automatic fixed bin(17,0) dcl 1472 in procedure "copy_from_user_to_us" set ref 1480* 1488 1494 1502 1508* 1508 target_ptr parameter pointer dcl 1467 in procedure "copy_from_user_to_us" ref 1455 1488 1494 1502 target_ptr 000312 automatic pointer dcl 125 in procedure "protocol_mpx" set ref 1076* 1077 target_ptr parameter pointer dcl 1246 in procedure "copy_chars" ref 1234 1265 1271 1279 tc_util$validate_processid 000052 constant entry external dcl 165 ref 1436 tcp 000146 automatic pointer dcl 81 set ref 792* 793 796 834 835* 836 837 838 839* 839 839 tidx 000157 automatic fixed bin(17,0) dcl 86 set ref 812* 829 830* 831* 831 timer_set 13(06) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 1014 1019* 1132* to_address 6 000227 automatic varying char(15) level 2 dcl 110 set ref 471* to_na 000105 automatic varying char(15) dcl 73 set ref 439* 467 471 total_string based char packed unaligned dcl 1476 in procedure "copy_from_user_to_us" set ref 1483 total_string based char packed unaligned dcl 1536 in procedure "copy_from_us_to_user" set ref 1542 transmit_info based structure level 1 dcl 2-61 tty_buf based structure level 1 dcl 5-35 tty_buf$ 000060 external static fixed bin(17,0) dcl 5-19 set ref 264 442 898 1164 tty_lock$lock_channel 000042 constant entry external dcl 159 ref 458 1175 1443 tty_lock$unlock_channel 000044 constant entry external dcl 160 ref 1404 1447 tty_space_man$free_buffer 000064 constant entry external dcl 8-14 ref 645 917 1084 tty_space_man$free_chain 000066 constant entry external dcl 8-16 ref 847 864 1295 1298 1365 1379 tty_space_man$get_buffer 000062 constant entry external dcl 8-13 ref 623 687 tty_space_man$needs_space 000070 constant entry external dcl 8-18 ref 592 725 1343 ttybp 000370 automatic pointer dcl 5-19 set ref 264* 265 442* 443 574 581 584 605 632 640 814 871 898* 907 1058 1070 1164* 1165 1295 1295 1298 1298 1330 1334 1354 1379 1379 twx parameter fixed bin(17,0) dcl 103 set ref 258 261 433 447* 478* 483 504 531 736 750 756 1163 unspec builtin function dcl 182 set ref 275* 284* 285* 330* 399* 904* 909* 909 974* 974 998* 1047* user_chars_p 000572 automatic pointer dcl 1526 set ref 1542* 1547 1553 1561 user_event 22 based fixed bin(71,0) level 2 dcl 1-46 set ref 464* 494* 983* 1003* 1037* 1105* 1120* 1146* 1308* 1369* user_index 000112 automatic fixed bin(17,0) dcl 74 set ref 436* 465 user_proc_id 20 based bit(36) level 2 dcl 1-46 set ref 463* 495* 983* 1003* 1037* 1105* 1115 1120* 1146* 1185 1185 1309* 1369* 1436* user_ref 24 based fixed bin(17,0) level 2 dcl 1-46 set ref 465* 493* 980 1001 1036 1104 1119 1145 1310* wflag 13(04) based bit(1) level 3 packed packed unaligned dcl 1-46 set ref 594* 724* 1030 1041* 1301* wire_proc$wire_me 000056 constant entry external dcl 168 ref 1395 write_entry 000163 automatic bit(1) packed unaligned dcl 87 set ref 527* 562* 652 691 714 721 721 730 write_first 64 based fixed bin(17,0) level 2 dcl 1-46 set ref 572 574 632 634* 700* 1027 1030 1139 1141 1298 1298 1298 1304* 1330 1374* 1375 1379 1379 1380* write_last 65 based fixed bin(17,0) level 2 dcl 1-46 set ref 603 605 630* 634 641 700 704* 1304* 1358* 1375* 1380* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ABORT internal static fixed bin(17,0) initial dcl 2-86 ACKNOWLEDGE_ECHNEGO_INIT internal static fixed bin(17,0) initial dcl 11-22 ACKNOWLEDGE_ECHNEGO_STOP internal static fixed bin(17,0) initial dcl 11-23 AWARD_ELIGIBILITY internal static fixed bin(17,0) initial dcl 14-7 BLOCK_PROCESS internal static fixed bin(17,0) initial dcl 14-7 CALL_RING_0_TTY internal static fixed bin(17,0) initial dcl 14-7 FIRST_BOOTLOAD_PAGEX internal static fixed bin(17,0) initial dcl 16-166 FIRST_TTY_BUF_PAGEX internal static fixed bin(17,0) initial dcl 16-167 FNP_DUMP_PATCH_EVENT internal static fixed bin(17,0) initial dcl 5-31 FNP_METER_EVENT internal static fixed bin(17,0) initial dcl 5-32 HASP_MPX internal static fixed bin(17,0) initial dcl 4-16 IBM3270_MPX internal static fixed bin(17,0) initial dcl 4-16 INPUT_AVAILABLE internal static fixed bin(17,0) initial dcl 11-14 INPUT_REJECTED internal static fixed bin(17,0) initial dcl 11-16 LAP_MPX internal static fixed bin(17,0) initial dcl 4-16 LINE_1050 internal static fixed bin(17,0) initial dcl 12-22 LINE_2741 internal static fixed bin(17,0) initial dcl 12-22 LINE_ARDS internal static fixed bin(17,0) initial dcl 12-22 LINE_ASCII internal static fixed bin(17,0) initial dcl 12-22 LINE_ASYNC1 internal static fixed bin(17,0) initial dcl 12-22 LINE_ASYNC2 internal static fixed bin(17,0) initial dcl 12-22 LINE_ASYNC3 internal static fixed bin(17,0) initial dcl 12-22 LINE_BSC internal static fixed bin(17,0) initial dcl 12-22 LINE_COLTS internal static fixed bin(17,0) initial dcl 12-22 LINE_DSA internal static fixed bin(17,0) initial dcl 12-22 LINE_ETX internal static fixed bin(17,0) initial dcl 12-22 LINE_G115 internal static fixed bin(17,0) initial dcl 12-22 LINE_HASP_OPR internal static fixed bin(17,0) initial dcl 12-22 LINE_HDLC internal static fixed bin(17,0) initial dcl 12-22 LINE_MC internal static fixed bin(17,0) initial dcl 12-22 LINE_POLLED_VIP internal static fixed bin(17,0) initial dcl 12-22 LINE_SYNC1 internal static fixed bin(17,0) initial dcl 12-22 LINE_SYNC2 internal static fixed bin(17,0) initial dcl 12-22 LINE_SYNC3 internal static fixed bin(17,0) initial dcl 12-22 LINE_SYNCH internal static fixed bin(17,0) initial dcl 12-22 LINE_TELNET internal static fixed bin(17,0) initial dcl 12-22 LINE_UNKNOWN internal static fixed bin(17,0) initial dcl 12-22 LINE_VIP internal static fixed bin(17,0) initial dcl 12-22 LINE_X25LAP internal static fixed bin(17,0) initial dcl 12-22 Log_message_or_discard internal static fixed bin(17,0) initial dcl 13-14 MASKED internal static fixed bin(17,0) initial dcl 11-26 MAX_TRANSITION internal static fixed bin(17,0) initial dcl 14-7 MCS_MPX internal static fixed bin(17,0) initial dcl 4-16 NON_TTY_WAKEUP internal static fixed bin(17,0) initial dcl 14-7 QUIT internal static fixed bin(17,0) initial dcl 11-17 RETURN_RING_0_TTY internal static fixed bin(17,0) initial dcl 14-7 STY_MPX internal static fixed bin(17,0) initial dcl 4-16 SYSTEM1_MPX internal static fixed bin(17,0) initial dcl 4-16 SYSTEM2_MPX internal static fixed bin(17,0) initial dcl 4-16 TTY_AREA_LOCK_EVENT internal static bit(36) initial dcl 5-33 TTY_MPX internal static fixed bin(17,0) initial dcl 4-16 TTY_WAKEUP internal static fixed bin(17,0) initial dcl 14-7 UNCP_MPX internal static fixed bin(17,0) initial dcl 4-16 USER1_MPX internal static fixed bin(17,0) initial dcl 4-16 USER2_MPX internal static fixed bin(17,0) initial dcl 4-16 USER3_MPX internal static fixed bin(17,0) initial dcl 4-16 USER4_MPX internal static fixed bin(17,0) initial dcl 4-16 USER5_MPX internal static fixed bin(17,0) initial dcl 4-16 VIP7760_MPX internal static fixed bin(17,0) initial dcl 4-16 WRU_TIMEOUT internal static fixed bin(17,0) initial dcl 11-20 Write_and_crash_system internal static fixed bin(17,0) initial dcl 13-14 Write_on_console internal static fixed bin(17,0) initial dcl 13-14 Write_with_alarm internal static fixed bin(17,0) initial dcl 13-14 Write_with_alarm_and_terminate internal static fixed bin(17,0) initial dcl 13-14 X25_MPX internal static fixed bin(17,0) initial dcl 4-16 abs_buf_limit internal static fixed bin(18,0) initial dcl 5-19 bsizec internal static fixed bin(17,0) initial dcl 5-28 buf_per_second internal static fixed bin(17,0) initial dcl 5-29 channel_manager$check_modes 000000 constant entry external dcl 10-19 channel_manager$get_modes 000000 constant entry external dcl 10-22 channel_manager$interrupt 000000 constant entry external dcl 10-25 channel_manager$interrupt_later 000000 constant entry external dcl 10-28 channel_manager$queued_interrupt 000000 constant entry external dcl 10-31 channel_manager$read 000000 constant entry external dcl 10-7 channel_manager$set_modes 000000 constant entry external dcl 10-16 disconnect_info automatic structure level 1 packed packed unaligned dcl 2-51 fnpp automatic pointer dcl 16-50 free_block based structure level 1 dcl 7-23 free_blockp automatic pointer dcl 7-20 input_bpart internal static fixed bin(18,0) initial dcl 5-19 layer3_IP internal static fixed bin(17,0) initial dcl 3-19 layer3_X29 internal static fixed bin(17,0) initial dcl 3-20 layer3_XNS internal static fixed bin(17,0) initial dcl 3-21 lct_size automatic fixed bin(17,0) dcl 9-9 line_types internal static char(16) initial array packed unaligned dcl 12-54 lock_ptr automatic pointer dcl 6-9 max_line_type internal static fixed bin(17,0) initial dcl 12-48 mcs_timer$change 000000 constant entry external dcl 15-5 mcs_timer$reset 000000 constant entry external dcl 15-6 mpx_special_lock internal static bit(1) initial array packed unaligned dcl 4-40 mpx_types internal static char(32) initial array packed unaligned dcl 4-35 n_sync_line_types internal static fixed bin(17,0) initial dcl 12-50 protocol_channels automatic fixed bin(17,0) dcl 1-23 qblock_size internal static fixed bin(17,0) initial dcl 5-27 saved_meters based structure level 1 dcl 9-68 sync_line_type internal static fixed bin(17,0) initial array dcl 12-52 timer_info automatic structure level 1 dcl 11-50 transmit_info_entries automatic fixed bin(17,0) dcl 2-59 tty_ev internal static fixed bin(17,0) initial dcl 5-19 tty_space_man$free_space 000000 constant entry external dcl 8-12 tty_space_man$get_chain 000000 constant entry external dcl 8-15 tty_space_man$get_perm_space 000000 constant entry external dcl 8-11 tty_space_man$get_space 000000 constant entry external dcl 8-10 tty_space_man$switch_chain 000000 constant entry external dcl 8-17 wakeup_names internal static char(9) initial array packed unaligned dcl 2-88 NAMES DECLARED BY EXPLICIT CONTEXT. bad_args 002631 constant label dcl 550 ref 515 515 554 793 798 804 809 bad_int 006166 constant label dcl 1153 ref 905 bad_pxss_status 007135 constant entry internal dcl 1411 ref 959 1009 check_length 006365 constant entry internal dcl 1212 ref 557 817 872 check_orphan_connections 007210 constant entry internal dcl 1429 ref 446 check_rest 004362 constant label dcl 868 ref 818 cleaner 007114 constant entry internal dcl 1399 ref 457 486 511 539 739 765 1195 compute_max_nsdu_size 007600 constant entry internal dcl 1571 ref 916 977 copy_chars 006440 constant entry internal dcl 1234 ref 626 654 693 835 855 copy_from_us_to_user 007463 constant entry internal dcl 1513 ref 830 copy_from_user_to_us 007356 constant entry internal dcl 1455 ref 652 691 g_i 003737 constant label dcl 761 ref 754 get_channel 006320 constant entry internal dcl 1198 ref 448 get_info 003713 constant entry external dcl 756 hpriv_control 000633 constant entry external dcl 233 illdet 006220 constant label dcl 1191 ref 1181 1185 init_multiplexer 001001 constant entry external dcl 258 interrupt 004430 constant entry external dcl 888 inv_state 002621 constant label dcl 543 ref 513 ncon_req 002007 constant entry external dcl 433 ncon_resp 002257 constant entry external dcl 483 ndis_req 003552 constant entry external dcl 736 ndt_req 002543 constant entry external dcl 531 priv_control 000570 constant entry external dcl 222 protocol_mpx 000362 constant entry external dcl 22 read 003660 constant entry external dcl 750 remove_listener 001615 constant entry external dcl 385 remove_special_listener 001667 constant entry external dcl 402 reset_channel 006555 constant entry internal dcl 1291 ref 477 745 1012 send_common 002656 constant label dcl 563 ref 529 send_next_nsdu 006654 constant entry internal dcl 1322 ref 718 1027 1139 set_listener 001341 constant entry external dcl 334 set_special_listener 001412 constant entry external dcl 351 set_static 007100 constant entry internal dcl 1388 ref 287 setup 006232 constant entry internal dcl 1160 ref 487 512 540 740 766 shutdown 000504 constant entry external dcl 211 start 000374 constant entry external dcl 188 stop 000460 constant entry external dcl 202 terminate_multiplexer 001243 constant entry external dcl 316 try_to_send 003474 constant label dcl 718 ref 688 unlock 006223 constant label dcl 1193 ref 459 479 491 502 525 545 552 559 568 595 733 748 886 1172 1176 write 002407 constant entry external dcl 504 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 10656 10762 10046 10666 Length 11650 10046 104 652 607 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME protocol_mpx 624 external procedure is an external procedure. on unit on line 457 64 on unit on unit on line 486 64 on unit on unit on line 511 64 on unit on unit on line 539 64 on unit on unit on line 739 64 on unit on unit on line 765 64 on unit setup internal procedure shares stack frame of external procedure protocol_mpx. get_channel internal procedure shares stack frame of external procedure protocol_mpx. check_length internal procedure shares stack frame of external procedure protocol_mpx. copy_chars internal procedure shares stack frame of external procedure protocol_mpx. reset_channel internal procedure shares stack frame of external procedure protocol_mpx. send_next_nsdu internal procedure shares stack frame of external procedure protocol_mpx. set_static internal procedure shares stack frame of external procedure protocol_mpx. cleaner 68 internal procedure is called by several nonquick procedures. bad_pxss_status internal procedure shares stack frame of external procedure protocol_mpx. check_orphan_connections internal procedure shares stack frame of external procedure protocol_mpx. copy_from_user_to_us internal procedure shares stack frame of external procedure protocol_mpx. copy_from_us_to_user internal procedure shares stack frame of external procedure protocol_mpx. compute_max_nsdu_size internal procedure shares stack frame of external procedure protocol_mpx. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 ever_initialized protocol_mpx 000011 no_write_code protocol_mpx 000012 noalloc_code protocol_mpx STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME protocol_mpx 000100 from_na protocol_mpx 000105 to_na protocol_mpx 000112 user_index protocol_mpx 000113 call_data protocol_mpx 000130 bytes_processed protocol_mpx 000131 scx protocol_mpx 000132 miip protocol_mpx 000134 order protocol_mpx 000144 scp protocol_mpx 000146 tcp protocol_mpx 000150 scl protocol_mpx 000152 cscp protocol_mpx 000154 length_to_copy protocol_mpx 000155 sci protocol_mpx 000156 scidx protocol_mpx 000157 tidx protocol_mpx 000160 break protocol_mpx 000161 stop protocol_mpx 000162 end_chain protocol_mpx 000163 write_entry protocol_mpx 000164 read_entry protocol_mpx 000165 buf_size protocol_mpx 000166 protocol_id protocol_mpx 000167 orig_buf_size protocol_mpx 000170 lchar protocol_mpx 000171 cur_space protocol_mpx 000172 cur_chain_len protocol_mpx 000173 max_space protocol_mpx 000174 max_chars protocol_mpx 000175 max_chars_in_buf protocol_mpx 000176 chars_in_buf protocol_mpx 000200 new_bufp protocol_mpx 000202 headp protocol_mpx 000204 lastp protocol_mpx 000206 prevp protocol_mpx 000210 new_buf protocol_mpx 000211 code protocol_mpx 000212 event protocol_mpx 000222 i protocol_mpx 000223 m protocol_mpx 000224 n protocol_mpx 000225 devx protocol_mpx 000226 locked protocol_mpx 000227 CON_REQ_info protocol_mpx 000264 net_infos protocol_mpx 000272 ignore_code protocol_mpx 000273 int_type protocol_mpx 000274 inchain protocol_mpx 000275 next_offset protocol_mpx 000276 last_offset protocol_mpx 000300 new_headp protocol_mpx 000302 old_tailp protocol_mpx 000304 new_first_tally protocol_mpx 000305 old_last_tally protocol_mpx 000306 max_tally protocol_mpx 000307 filled protocol_mpx 000310 source_ptr protocol_mpx 000312 target_ptr protocol_mpx 000314 pxss_status protocol_mpx 000315 process_id protocol_mpx 000316 partial protocol_mpx 000320 protocol_data_ptr protocol_mpx 000322 channel_ptr protocol_mpx 000324 pinfop protocol_mpx 000326 DIALUP_info protocol_mpx 000330 NCON_IND_info protocol_mpx 000366 protocol_event_message protocol_mpx 000370 ttybp protocol_mpx 000372 blockp protocol_mpx 000374 lctp protocol_mpx 000376 lctep protocol_mpx 000400 lcntp protocol_mpx 000402 interrupt_info protocol_mpx 000404 dialup_info protocol_mpx 000406 rtx_info protocol_mpx 000410 infop protocol_mpx 000460 i get_channel 000470 stop check_length 000500 n copy_chars 000501 nctc copy_chars 000502 target_offset copy_chars 000503 n_chars_in_source_buffer copy_chars 000520 headp send_next_nsdu 000522 next_head send_next_nsdu 000556 source_chars_p copy_from_user_to_us 000560 n copy_from_user_to_us 000561 nctc copy_from_user_to_us 000562 target_offset copy_from_user_to_us 000563 n_chars_in_source_buffer copy_from_user_to_us 000572 user_chars_p copy_from_us_to_user 000574 target_offset copy_from_us_to_user 000575 n copy_from_us_to_user 000576 nctc copy_from_us_to_user 000577 n_chars_in_source_buffer copy_from_us_to_user 000606 i compute_max_nsdu_size THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this call_int_other return_mac mpfx2 enable_op ext_entry ext_entry_desc int_entry trunc_fx2 ceil_fx2 divide_fx1 clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. channel_manager$control channel_manager$write mcs_timer$reset_all mcs_timer$set pxss$ring_0_wakeup pxss$unique_ring_0_wakeup syserr tc_util$validate_processid tty_lock$lock_channel tty_lock$unlock_channel tty_space_man$free_buffer tty_space_man$free_chain tty_space_man$get_buffer tty_space_man$needs_space wire_proc$wire_me THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. dn355_data$ error_table_$action_not_performed error_table_$bad_arg error_table_$buffer_big error_table_$invalid_device error_table_$invalid_state error_table_$invalid_write error_table_$io_no_permission error_table_$noalloc error_table_$resource_unavailable error_table_$undefined_order_request pds$processid tty_buf$ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 22 000361 186 000367 188 000370 191 000406 192 000407 193 000412 194 000414 195 000415 196 000417 198 000453 199 000455 202 000456 204 000472 205 000475 206 000477 207 000500 208 000501 211 000502 213 000516 214 000521 215 000522 216 000524 218 000560 219 000562 222 000563 225 000612 226 000615 227 000623 228 000626 229 000627 230 000630 233 000631 235 000655 236 000660 237 000666 238 000671 239 000672 240 000674 243 000705 244 000742 246 000744 247 000752 248 000754 249 000757 251 000761 252 000762 253 000766 254 000771 255 000773 258 000774 261 001015 262 001017 263 001022 264 001024 265 001026 266 001030 267 001032 268 001036 269 001040 270 001041 272 001042 274 001044 275 001053 276 001061 277 001066 278 001070 279 001071 280 001072 281 001073 282 001075 283 001077 284 001102 285 001105 286 001110 287 001122 288 001123 291 001126 293 001132 294 001151 295 001154 297 001155 298 001156 299 001165 300 001171 302 001174 303 001203 304 001205 305 001207 306 001211 307 001212 309 001213 310 001215 311 001235 312 001240 316 001241 319 001255 320 001256 321 001257 322 001262 323 001265 324 001267 325 001275 326 001300 330 001326 331 001332 332 001334 334 001335 336 001353 337 001355 338 001360 339 001361 340 001364 341 001366 343 001372 344 001374 346 001375 347 001400 348 001403 349 001404 351 001405 353 001426 354 001434 355 001436 356 001444 357 001445 358 001446 359 001463 360 001465 362 001475 363 001500 365 001501 366 001504 367 001506 368 001510 369 001530 370 001532 373 001555 374 001557 376 001562 377 001565 379 001566 380 001574 381 001603 382 001606 383 001610 385 001611 387 001625 388 001630 389 001631 390 001634 391 001636 393 001642 394 001644 396 001645 397 001646 399 001656 400 001662 402 001663 404 001701 405 001707 406 001710 407 001711 409 001716 410 001721 412 001722 413 001725 414 001727 416 001746 417 001750 419 001753 420 001756 422 001757 425 001771 426 001772 427 001774 428 001775 430 002000 433 002001 436 002025 437 002030 438 002032 439 002040 440 002046 442 002054 443 002057 444 002061 445 002063 446 002065 447 002066 448 002067 449 002071 451 002073 452 002076 454 002077 455 002103 456 002105 457 002106 458 002130 459 002141 461 002143 463 002145 464 002152 465 002155 466 002157 467 002161 468 002166 470 002170 471 002171 472 002176 473 002203 474 002210 475 002240 477 002246 478 002247 479 002251 483 002252 485 002273 486 002274 487 002316 488 002317 490 002323 491 002326 493 002327 494 002332 495 002334 496 002337 497 002371 499 002373 500 002376 502 002400 504 002401 506 002427 507 002432 508 002435 509 002437 510 002440 511 002441 512 002463 513 002464 515 002470 520 002510 521 002511 522 002521 523 002524 524 002526 525 002530 527 002532 528 002534 529 002535 531 002536 534 002561 535 002565 536 002567 537 002570 538 002571 539 002572 540 002614 541 002615 543 002621 545 002624 548 002625 550 002631 552 002634 554 002635 556 002643 557 002645 558 002647 559 002651 561 002653 562 002655 563 002656 565 002657 567 002662 568 002665 570 002666 571 002667 572 002670 574 002672 575 002675 576 002676 577 002700 578 002706 579 002707 581 002716 582 002721 584 002722 588 002742 590 002746 592 002750 594 002763 595 002765 597 002766 598 002773 599 002775 600 003002 603 003006 605 003010 606 003015 610 003030 611 003037 612 003041 613 003042 614 003044 615 003054 618 003072 619 003074 621 003075 623 003100 624 003115 626 003121 628 003132 629 003135 630 003140 632 003142 634 003146 638 003155 640 003167 641 003173 645 003200 646 003213 648 003215 649 003216 651 003226 652 003242 654 003252 655 003257 656 003261 657 003264 659 003270 660 003272 661 003277 662 003301 667 003304 668 003310 669 003315 671 003317 672 003321 673 003323 675 003324 676 003325 677 003327 678 003332 679 003342 681 003347 682 003351 683 003352 685 003354 687 003361 688 003376 690 003402 691 003404 693 003412 694 003415 695 003417 696 003421 697 003424 698 003427 700 003433 703 003440 704 003444 705 003446 706 003450 707 003452 708 003454 710 003457 712 003464 713 003466 714 003471 718 003474 721 003501 724 003513 725 003516 728 003530 729 003532 730 003534 732 003542 733 003545 736 003546 738 003566 739 003567 740 003611 741 003612 743 003616 744 003645 745 003650 746 003651 747 003652 748 003655 750 003656 752 003700 753 003702 754 003704 756 003705 759 003733 760 003736 761 003737 763 003742 764 003745 765 003746 766 003770 768 003771 770 003774 772 004000 773 004006 774 004013 775 004020 776 004025 777 004030 778 004032 779 004033 780 004034 781 004037 783 004040 786 004046 788 004050 790 004054 792 004056 793 004060 795 004064 796 004066 797 004072 798 004073 800 004076 801 004103 802 004111 804 004112 806 004116 807 004117 808 004127 809 004133 811 004140 812 004142 814 004144 815 004154 817 004155 818 004157 820 004162 822 004165 823 004167 825 004171 826 004172 827 004176 829 004200 830 004210 831 004213 832 004214 834 004215 835 004226 836 004231 837 004233 838 004236 839 004240 841 004244 842 004246 843 004251 845 004260 847 004264 849 004277 850 004302 852 004303 854 004307 855 004311 856 004314 857 004317 858 004322 860 004325 861 004335 862 004341 863 004344 864 004347 868 004362 871 004365 872 004370 873 004372 874 004373 875 004376 877 004404 878 004406 879 004407 880 004411 881 004413 882 004414 883 004417 885 004420 886 004423 888 004424 893 004440 894 004443 895 004446 896 004452 897 004453 898 004455 899 004460 900 004462 902 004464 904 004467 905 004471 907 004475 908 004502 909 004505 910 004507 911 004513 912 004516 913 004520 914 004525 915 004532 916 004537 917 004540 919 004553 920 004554 921 004556 923 004564 925 004602 926 004604 927 004607 928 004612 930 004615 931 004617 932 004620 933 004631 934 004636 937 004660 940 004674 941 004676 943 004700 944 004702 945 004707 947 004711 949 004712 950 004715 952 004720 954 004722 955 004725 956 004727 957 004731 958 004733 959 004750 962 005007 963 005012 964 005014 965 005016 967 005020 968 005021 969 005052 970 005053 972 005055 974 005061 975 005063 976 005067 977 005072 978 005073 979 005076 980 005100 981 005104 982 005106 983 005110 985 005125 987 005164 988 005165 990 005212 992 005213 995 005221 998 005226 999 005231 1000 005234 1001 005236 1002 005241 1003 005243 1005 005257 1007 005262 1009 005277 1012 005304 1014 005305 1017 005314 1019 005337 1021 005342 1023 005343 1026 005351 1027 005353 1030 005356 1034 005367 1035 005372 1036 005374 1037 005377 1039 005414 1041 005453 1043 005456 1045 005457 1047 005462 1048 005464 1049 005467 1052 005472 1053 005475 1055 005500 1056 005502 1058 005503 1059 005507 1060 005511 1063 005514 1065 005517 1067 005524 1068 005525 1070 005532 1071 005535 1073 005540 1075 005543 1076 005545 1077 005552 1078 005556 1079 005560 1080 005564 1082 005571 1084 005574 1086 005607 1088 005610 1089 005612 1091 005613 1093 005616 1094 005622 1098 005625 1100 005631 1102 005640 1103 005643 1104 005645 1105 005650 1107 005665 1109 005724 1111 005727 1113 005730 1115 005732 1117 005735 1118 005740 1119 005742 1120 005745 1122 005761 1126 006020 1130 006021 1132 006023 1133 006026 1135 006064 1137 006065 1139 006067 1141 006073 1143 006101 1144 006104 1145 006106 1146 006111 1148 006126 1151 006165 1153 006166 1158 006217 1191 006220 1193 006223 1195 006225 1196 006231 1160 006232 1163 006233 1164 006235 1165 006240 1166 006242 1167 006244 1168 006246 1169 006250 1171 006254 1172 006256 1175 006257 1176 006267 1178 006271 1180 006273 1181 006300 1184 006304 1185 006306 1188 006317 1198 006320 1204 006322 1207 006356 1208 006361 1212 006365 1222 006367 1223 006370 1224 006375 1225 006402 1227 006412 1229 006426 1230 006432 1231 006437 1234 006440 1258 006442 1260 006444 1261 006450 1262 006456 1264 006460 1265 006462 1266 006472 1267 006473 1268 006474 1270 006475 1271 006476 1272 006506 1274 006515 1275 006520 1276 006521 1278 006522 1279 006524 1280 006534 1282 006543 1283 006546 1285 006547 1286 006551 1287 006554 1291 006555 1295 006556 1298 006577 1301 006620 1303 006631 1304 006633 1305 006635 1306 006637 1307 006641 1308 006642 1309 006643 1310 006644 1311 006645 1312 006646 1313 006647 1314 006650 1315 006651 1316 006652 1318 006653 1322 006654 1328 006655 1330 006661 1332 006667 1334 006703 1335 006706 1336 006707 1338 006712 1339 006714 1340 006717 1341 006732 1343 006736 1344 006744 1348 006745 1350 006751 1352 006753 1353 006755 1354 006762 1355 006765 1357 006766 1358 006772 1361 007000 1362 007003 1365 007004 1367 007017 1368 007022 1369 007024 1374 007043 1375 007046 1377 007051 1379 007053 1380 007072 1382 007075 1385 007077 1388 007100 1393 007101 1394 007104 1395 007106 1396 007112 1399 007113 1402 007121 1404 007124 1405 007132 1408 007134 1411 007135 1414 007137 1416 007145 1419 007175 1421 007203 1429 007210 1432 007211 1433 007221 1434 007225 1436 007230 1437 007241 1439 007243 1441 007267 1442 007272 1443 007275 1444 007307 1446 007311 1447 007343 1451 007353 1452 007355 1455 007356 1480 007360 1482 007362 1483 007366 1484 007377 1485 007402 1487 007404 1488 007406 1489 007414 1490 007415 1491 007416 1493 007417 1494 007420 1495 007426 1497 007433 1498 007434 1499 007435 1501 007436 1502 007440 1503 007446 1505 007453 1506 007454 1508 007455 1509 007457 1510 007462 1513 007463 1539 007465 1541 007467 1542 007474 1543 007505 1544 007512 1546 007514 1547 007516 1548 007523 1549 007524 1550 007525 1552 007526 1553 007527 1554 007534 1556 007543 1557 007546 1558 007547 1560 007550 1561 007552 1562 007557 1564 007566 1565 007571 1567 007572 1568 007574 1569 007577 1571 007600 1576 007601 1577 007607 1579 007617 1580 007637 ----------------------------------------------------------- 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