THIS FILE IS DAMAGED OPTION_suppress_ga initial (3), /* (SUPPRESS-GO-AHEAD) won't send go-ahead's */ 6 13 OPTION_nams initial (4), /* (NAMS) will control approximate message size */ 6 14 OPTION_status initial (5), /* (STATUS) will send option state information */ 6 15 OPTION_timing_mark initial (6), /* (TIMING-MARK) will put mark in return stream */ 6 16 OPTION_rcte initial (7), /* (RCTE) will send terminal control instructions */ 6 17 OPTION_line_width initial (8), /* (NAOL) will tell sender about line-width */ 6 18 OPTION_page_size initial (9), /* (NAOP) will tell sender about page-length */ 6 19 OPTION_naocrd initial (10), /* (NAOCRD) will tell sender about pads for CR's */ 6 20 OPTION_naohts initial (11), /* (NAOHTS) will tell sender where tab stops are */ 6 21 OPTION_naohtd initial (12), /* (NAOHTD) will tell sender about pads for HT's */ 6 22 OPTION_naoffd initial (13), /* (NAOFFD) will tell sender about pads for FF's */ 6 23 OPTION_naovts initial (14), /* (NAOVTS) will tell sender about vert tab stops */ 6 24 OPTION_naovtd initial (15), /* (NAOVTD) will tell sender about pads for VT's */ 6 25 OPTION_naolfd initial (16), /* (NAOLFD) will tell sender about pads for LF's */ 6 26 OPTION_exopl initial (255)) /* (EXTENDED-OPTIONS-LIST) will negotiate about */ 6 27 /* options with numbers gretaer than 255 */ 6 28 fixed binary (8) internal static; 6 29 6 30 /* end of include file "telnet_options.incl.pl1" */ 6 31 161 162 7 2 /* "telnet_special_chars.incl.pl1" -- this include file */ 7 3 /* declares the special bit patterns used over the data connection pair */ 7 4 /* within the Network TELNET protocol to perform control functions. */ 7 5 /* This include file contains the declarations of both the pre-processed */ 7 6 /* (Network defined) and the post-processed (internally defined) */ 7 7 /* versions of these patterns. */ 7 8 7 9 /* Originally created on 17 December, 1973 by D. M. Wells */ 7 10 7 11 declare 7 12 (NET_IAC initial ("377"b3), /* 255 - Interpret as Command */ 7 13 NET_DONT initial ("376"b3), /* 254 - DON'T Option Code */ 7 14 NET_DO initial ("375"b3), /* 253 - DO (Optioc Code) */ 7 15 NET_WONT initial ("374"b3), /* 252 - WON'T (Option Code) */ 7 16 NET_WILL initial ("373"b3), /* 251 - WILL (Option Code) */ 7 17 NET_SB initial ("372"b3), /* 250 - SB (Option Code) */ 7 18 NET_GA initial ("371"b3), /* 249 - Go Ahead */ 7 19 NET_EL initial ("370"b3), /* 248 - Erase Line */ 7 20 NET_EC initial ("367"b3), /* 247 - Erase Character */ 7 21 NET_AYT initial ("366"b3), /* 246 - Are You There ? */ 7 22 NET_AO initial ("365"b3), /* 245 - Abort Output */ 7 23 NET_IP initial ("364"b3), /* 244 - Interrupt Process */ 7 24 NET_BRK initial ("363"b3), /* 243 - NVT character BREAK */ 7 25 NET_DM initial ("362"b3), /* 242 - Data Mark (accompanies INS) */ 7 26 NET_NOP initial ("361"b3), /* 241 - No Operation */ 7 27 NET_SE initial ("360"b3)) /* 240 - Subnegotiation End (Option Code) */ 7 28 bit (9) internal static options (constant); 7 29 7 30 declare 7 31 (OUR_NOP initial ("777"b3), /* 511 - internal nop (discard) character */ 7 32 OUR_IAC initial ("776"b3), /* 510 - internal version of NET IAC */ 7 33 OUR_EL initial ("775"b3), /* 509 - internal kill line identifier */ 7 34 OUR_EC initial ("774"b3), /* 508 - internal erase char identifier */ 7 35 OUR_DM initial ("773"b3), /* 507 - internal data mark */ 7 36 OUR_EW initial ("772"b3), /* 506 - internal erase word identifier */ 7 37 OUR_DC initial ("771"b3), /* 505 - internal delete char identifier */ 7 38 OUR_DL initial ("770"b3), /* 504 - internal delete line identifier */ 7 39 OUR_DW initial ("767"b3), /* 503 - internal delete word identifier */ 7 40 OUR_SN initial ("766"b3), /* 502 - internal escape next identifier */ 7 41 OUR_RCTE_START initial ("765"b3), /* 501 - internal marker to tell position to */ 7 42 /* start RCTE processing */ 7 43 OUR_RCTE_END initial ("764"b3), /* 500 - internal marker to tell position to */ 7 44 /* stop RCTE processing */ 7 45 OUR_RCTE_SPECIAL_BREAK initial ("763"b3), /* 499 - internal marker for sequences that */ 7 46 /* must be treated as RCTE breaks */ 7 47 OUR_CAN_BREAK initial ("762"b3)) /* 498 - internal marker to keep track of */ 7 48 /* canonicalization break characters. */ 7 49 bit (9) internal static options (constant); 7 50 7 51 /* end of include file "telnet_special_chars.incl.pl1" */ 7 52 162 163 164 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 165 166 net_ascii_write_raw: /* internal entry to write without processing */ 167 entry (bv_SDB_ptr, bv_wksp_ptr, bv_offset, bv_nelem, bv_nelemt, bv_status); 168 169 string (bv_status) = ""b; 170 171 next_output = bv_offset; 172 num_output = bv_nelem; 173 174 do while ((num_output > 0) | (SDB.output_buffer.num_bytes > 0)); 175 call write_to_ncp (bv_wksp_ptr, next_output, num_output, xnt, "0"b, err_code); 176 if err_code ^= ""b 177 then goto return_from_write; 178 next_output = next_output + xnt; 179 num_output = num_output - xnt; 180 181 if (SDB.output_buffer.num_bytes > 0) 182 then do; 183 call block_for_write (); 184 185 call net_ascii_dim_state_$net_ascii_order (addr (SDB), "start", null (), bv_status); 186 end; 187 end; 188 189 bv_nelemt = bv_nelem; 190 191 string (bv_status) = ""b; 192 193 return; 194 195 /* * * * * * * * * * * * * * * * * * * * * * * * */ 196 197 net_ascii_write: /* entry to write on typewriter */ 198 entry (bv_SDB_ptr, bv_wksp_ptr, bv_offset, bv_nelem, bv_nelemt, bv_status); 199 200 string (bv_status) = ""b; /* initialize status code to zero */ 201 202 bv_nelemt = 0; 203 204 if SDB.w_ncp_idx = -1 then do; 205 err_code = error_table_$invalid_write; 206 goto return_from_write; 207 end; 208 209 wksp_ptr = bv_wksp_ptr; 210 211 if SDB.current_terminal_state.aborting_output 212 then do; 213 bv_nelemt = bv_nelem; 214 err_code = ""b; 215 goto return_from_write; 216 end; 217 218 if SDB.current_modes.rawo 219 then do; 220 next_output = bv_offset; 221 num_output = bv_nelem; 222 223 do while ((num_output > 0) | (SDB.output_buffer.num_bytes > 0)); 224 call write_to_ncp (wksp_ptr, next_output, num_output, xnt, (SDB.do_telnet), err_code); 225 if err_code ^= ""b 226 then goto return_from_write; 227 next_output = next_output + xnt; 228 num_output = num_output - xnt; 229 230 if (SDB.output_buffer.num_bytes > 0) 231 then call block_for_write (); 232 end; 233 end; 234 else do; 235 first_input = bv_offset; 236 next_input = first_input; 237 last_input = first_input + bv_nelem - 1; 238 next_out = lbound (buffer2, 1); 239 240 do while (next_input <= last_input); 241 if SDB.device_state.in_page_wait 242 then do; 243 string (delimiter_array) = ""b; 244 delimiter_array (12) = "1"b; 245 246 do while (SDB.device_state.in_page_wait); 247 if detected_a_break_condition (xnt, err_code) 248 then do; 249 if err_code ^= ""b 250 then goto return_from_write; 251 252 SDB.rawbuffer_ptr -> byte_buffer.byte (SDB.rawbuffer_ptr -> byte_buffer.byte_offset + xnt - 1) = OUR_NOP; 253 SDB.device_state.actual_line = 0; 254 SDB.device_state.desired_line = 0; 255 SDB.device_state.in_page_wait = "0"b; 256 end; 257 258 if err_code ^= ""b 259 then goto return_from_write; 260 261 if SDB.device_state.in_page_wait 262 then call block_for_read (); 263 end; 264 call net_ascii_dim_state_$net_ascii_order (bv_SDB_ptr, "start", null (), bv_status); 265 end; 266 267 call net_convert_output_ (addr (SDB.device_state), wksp_ptr, next_input, last_input, 268 addr (buffer2), next_out, hbound (buffer2, 1), err_code); 269 if err_code ^= ""b 270 then goto return_from_write; 271 272 next_output = lbound (buffer2, 1); 273 num_output = next_out; 274 275 do while ((num_output > 0) | (SDB.output_buffer.num_bytes > 0)); 276 call write_to_ncp (addr (buffer2), next_output, num_output, xnt, (SDB.do_telnet), err_code); 277 if err_code ^= ""b 278 then goto return_from_write; 279 next_output = next_output + xnt; 280 num_output = num_output - xnt; 281 282 if SDB.output_buffer.num_bytes > 0 283 then call block_for_write (); 284 end; 285 286 next_out = lbound (buffer2, 1); 287 bv_nelemt = next_input - first_input; 288 end; 289 end; 290 291 bv_nelemt = bv_nelem; 292 293 string (bv_status.trans_state) = "11101"b; /* return I/O completion indicators */ 294 295 return; 296 297 return_from_write: 298 bv_status.error_code = err_code; 299 return; 300 301 /* * * * * * * * * * * * * * * * * * * * * * * * */ 302 303 net_ascii_read_no_block: /* entry to read from typewriter, but never block */ 304 entry (bv_SDB_ptr, bv_wksp_ptr, bv_offset, bv_nelem, bv_nelemt, bv_status); 305 306 string (bv_status) = ""b; 307 err_code = ""b; 308 309 SDB.current_terminal_state.aborting_output = "0"b; 310 311 bv_nelemt = 0; 312 313 if SDB.r_ncp_idx = -1 314 then do; 315 err_code = error_table_$invalid_read; 316 goto return_from_read; 317 end; 318 319 have_shipped_GA = (^ SDB.protocol_495); 320 321 call read_from_network (bv_wksp_ptr, bv_offset, bv_nelem, bv_nelemt, err_code); 322 if err_code ^= ""b 323 then goto return_from_read; 324 if bv_nelemt = 0 325 then do; 326 if SDB.string_ptr = null () 327 then do; 328 if (^ have_shipped_GA) & (SDB.do_telnet) & (^SDB.option_in_effect (TRANSMIT).option(OPTION_suppress_ga)) /* may change as time goes on */ 329 then call net_ascii_write_raw (bv_SDB_ptr, addr (IAC_GA), 0, 2, (0), bv_status); 330 have_shipped_GA = "1"b; 331 end; 332 end; 333 334 string (bv_status.trans_state) = "11111"b; 335 if SDB.string_ptr = null () 336 then bv_status.successful_physical_completion = "0"b; 337 338 return; 339 340 /* * * * * * * * * * * * * * * * * * * * * * * * */ 341 342 net_ascii_read: /* entry to read from typewriter */ 343 entry (bv_SDB_ptr, bv_wksp_ptr, bv_offset, bv_nelem, bv_nelemt, bv_status); 344 345 string (bv_status) = ""b; /* initialize status code to zero */ 346 err_code = ""b; 347 SDB.current_terminal_state.aborting_output = "0"b; 348 349 bv_nelemt = 0; /* initialize elements transferred to zero */ 350 351 if SDB.r_ncp_idx = -1 then do; 352 err_code = error_table_$invalid_read; 353 goto return_from_read; 354 end; 355 356 have_shipped_GA = ^ SDB.protocol_495; 357 358 do while (bv_nelemt = 0); 359 call read_from_network (bv_wksp_ptr, bv_offset, bv_nelem, bv_nelemt, err_code); 360 if err_code ^= ""b 361 then goto return_from_read; 362 if bv_nelemt = 0 363 then do; 364 if (^ have_shipped_GA) & (SDB.do_telnet) & (^ SDB.option_in_effect (TRANSMIT).option(OPTION_suppress_ga)) 365 then do; 366 call net_ascii_write_raw (bv_SDB_ptr, addr (IAC_GA), 0, 2, (0), bv_status); 367 have_shipped_GA = "1"b; 368 end; 369 else do; 370 call block_for_read (); 371 end; 372 end; 373 end; 374 375 return_from_read: 376 SDB.current_terminal_state.aborting_output = "0"b; 377 string (bv_status.trans_state) = "11111"b; 378 bv_status.error_code = err_code; 379 380 return; 381 382 /* * * * * * * * * * * * * * * * * * * * * * * * */ 383 384 net_ascii_resetread: /* entry to reset read-ahead data */ 385 entry (bv_SDB_ptr, bv_status); 386 387 string (bv_status) = ""b; 388 389 if SDB.r_ncp_idx = -1 then do; 390 err_code = error_table_$invalid_read; 391 goto abort_err; 392 end; 393 394 /* In order to do a resetread, while also remembering */ 395 /* to process any telnet control that comes through, we */ 396 /* will simply read until we don't get anything. In order */ 397 /* to get all such characters, however, we will set all */ 398 /* characters as break characters. */ 399 400 string (delimiter_array) = ""b; 401 string (delimiter_array) = ^ string (delimiter_array); 402 403 do while (detected_a_break_condition (next_input, err_code)); 404 temp_ptr = SDB.rawbuffer_ptr; 405 406 temp_ptr -> byte_buffer.byte_offset = temp_ptr -> byte_buffer.byte_offset + next_input; 407 temp_ptr -> byte_buffer.num_bytes = temp_ptr -> byte_buffer.num_bytes - next_input; 408 end; 409 if err_code ^= ""b 410 then goto return_from_read; 411 412 if SDB.string_ptr ^= null () 413 then do; 414 free SDB.string_ptr -> byte_buffer in (SDB.area_ptr -> based_area); 415 SDB.string_ptr = null (); 416 end; 417 418 string (bv_status) = ""b; 419 420 return; 421 422 /* * * * * * * * * * * * * * * * * * * * * * * * */ 423 424 net_ascii_resetwrite: /* entry to reset write-behind buffers */ 425 entry (bv_SDB_ptr, bv_status); 426 427 string (bv_status) = ""b; 428 429 SDB.current_terminal_state.aborting_output = "0"b; 430 431 if SDB.w_ncp_idx = -1 then do; 432 err_code = error_table_$invalid_write; 433 goto abort_err; 434 end; 435 436 if SDB.protocol_495 437 then do; 438 call net_ascii_write_raw (bv_SDB_ptr, addr (IAC_DM), 0, 2, (0), bv_status); 439 call ncp_$send_interrupt (SDB.w_ncp_idx, (0), err_code); 440 end; 441 else do; 442 call ncp_$discard_buffered_data (SDB.w_ncp_idx, state, err_code); 443 if (err_code ^= ""b) | (state ^= OPEN_STATE) then goto abort_err; 444 end; 445 446 return; 447 448 /* * * * * * * * * * * * * * * * * * * * * * * * */ 449 450 net_ascii_abort: /* entry to reset read, write and quit conditions */ 451 entry (bv_SDB_ptr, bv_old_status, bv_status); 452 453 454 call net_ascii_resetwrite (bv_SDB_ptr, bv_status); 455 456 call net_ascii_resetread (bv_SDB_ptr, bv_status); 457 458 string (bv_status) = ""b; 459 460 return; 461 462 abort_err: 463 if err_code ^= ""b 464 then bv_status.error_code = err_code; 465 else bv_status.error_code = error_table_$net_invalid_state; 466 467 return; 468 469 /* * * * * * * * * * * * * * * * * * * * * * * * */ 470 471 net_ascii_signal_handler: 472 entry (bv_mc_ptr, bv_condition_name, bv_SDB_ptr, bv_crawlout_ptr, bv_continue_switch); 473 474 have_machine_conditions = "1"b; 475 476 if bv_mc_ptr ^= null () 477 then bv_mc_ptr -> mc.fcode = bit (binary (quit_sct_index, 17)); 478 479 if ^ SDB.protocol_495 480 then do; 481 if SDB.allow_quits 482 then call signal_ ("quit", bv_mc_ptr, null (), bv_crawlout_ptr); 483 return; 484 end; 485 486 timeout_time = clock_ () + 1000000 * SDB.timeout_value; 487 488 call timer_manager_$alarm_wakeup (timeout_time, "00"b, SDB.read_event_channel); 489 490 string (delimiter_array) = ""b; 491 delimiter_array (binary (OUR_DM, 9)) = "1"b; 492 493 do while (^ detected_a_break_condition (next_input, err_code)); 494 if err_code ^= ""b 495 then return; 496 if clock_ () > timeout_time 497 then return; 498 499 call block_for_read (); 500 end; 501 502 call net_ascii_dim_state_$net_ascii_order (addr (SDB), "start", null (), dummy_status); 503 504 return; 505 506 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 507 508 write_to_ncp: 509 procedure (bv_buff_ptr, bv_first_offset, bv_num_elements, bv_num_elements_proc, bv_external_data, bv_err_code); 510 511 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 512 513 declare 514 ((bv_first_offset, bv_num_elements, bv_num_elements_proc) fixed binary (24), 515 bv_external_data bit (1) aligned, 516 bv_err_code bit (36) aligned, 517 bv_buff_ptr pointer) 518 parameter; 519 520 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 521 522 declare 523 ((first_loc, indx, next_free_loc, num_free_locs, num_transmitted) fixed binary (24), 524 previous_mask bit (36) aligned, 525 buffer_ptr pointer, 526 transfer_proc variable entry (ptr, ptr, fixed bin (24), fixed bin (24), ptr, fixed bin (24), fixed bin (24), bit (36) aligned)) 527 automatic; 528 529 /* * * * * * * * * * * * * * * * * * * * * * * * */ 530 531 first_loc = bv_first_offset; 532 buffer_ptr = bv_buff_ptr; 533 534 if bv_external_data 535 then transfer_proc = net_convert_bytesize_$telnet_9_to_8; 536 else transfer_proc = net_convert_bytesize_$direct_9_to_8; 537 538 call hcs_$set_ips_mask (enable_mask, previous_mask); 539 540 if SDB.output_buffer.num_bytes = 0 541 then SDB.output_buffer.byte_offset = 0; 542 543 next_free_loc = SDB.output_buffer.byte_offset + SDB.output_buffer.num_bytes; 544 indx = first_loc; 545 546 call transfer_proc (null (), buffer_ptr, indx, bv_num_elements + first_loc - 1, 547 addr (SDB.output_buffer.byte8), next_free_loc, SDB.output_buffer.buffer_bound, bv_err_code); 548 549 bv_num_elements_proc = indx - first_loc; 550 SDB.output_buffer.num_bytes = next_free_loc - SDB.output_buffer.byte_offset; 551 552 call net_$ncp_write (SDB.w_ncp_idx, addr (SDB.output_buffer.byte8 (SDB.output_buffer.byte_offset)), 553 SDB.output_buffer.num_bytes, num_transmitted, state, bv_err_code); 554 if state ^= 6 555 then connection_state = 1; /* connection has been closed */ 556 SDB.output_buffer.byte_offset = SDB.output_buffer.byte_offset + num_transmitted; 557 SDB.output_buffer.num_bytes = SDB.output_buffer.num_bytes - num_transmitted; 558 559 call hcs_$set_ips_mask (previous_mask, ((36)"0"b)); 560 561 if bv_err_code ^= ""b 562 then return; 563 564 return; 565 566 end write_to_ncp; 567 568 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 569 570 block_for_write: 571 procedure (); 572 573 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 574 575 declare 576 1 ipc_event_list aligned automatic, 577 2 num_chans fixed binary (17), 578 2 event_channel fixed binary (71); 579 580 /* * * * * * * * * * * * * * * * * * * * * * * * */ 581 582 call timer_manager_$alarm_wakeup ((6 * SDB.timeout_value), "11"b, SDB.write_event_channel); 583 584 ipc_event_list.num_chans = 1; 585 ipc_event_list.event_channel = SDB.write_event_channel; 586 587 call ipc_$block (addr (ipc_event_list), addr (event_message), err_code); 588 if err_code ^= ""b 589 then signal net_ascii_ipc_error_; 590 591 call timer_manager_$reset_alarm_wakeup (SDB.write_event_channel); 592 593 return; 594 595 end block_for_write; 596 597 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 598 599 block_for_read: 600 procedure (); 601 602 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 603 604 declare 605 1 ipc_event_list aligned automatic, 606 2 num_chans fixed binary (17), 607 2 event_channel fixed binary (71); 608 609 /* * * * * * * * * * * * * * * * * * * * * * * * */ 610 611 ipc_event_list.num_chans = 1; 612 ipc_event_list.event_channel = SDB.read_event_channel; 613 614 call ipc_$block (addr (ipc_event_list), addr (event_message), err_code); 615 if err_code ^= ""b 616 then signal net_ascii_ipc_error_; 617 618 return; 619 620 end block_for_read; 621 622 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 623 624 read_from_network: 625 procedure (bv_buffer_ptr, bv_first_offset, bv_num_elements, bv_num_elements_trans, bv_err_code); 626 627 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 628 629 declare 630 ((bv_first_offset, bv_num_elements, bv_num_elements_trans) fixed binary (24), 631 bv_err_code bit (36) aligned, 632 bv_buffer_ptr pointer) 633 parameter; 634 635 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 636 637 declare 638 ((first_offset, num_elements, num_to_read) fixed binary (24), 639 (ext_buffer_ptr, ext_wksp_ptr, read_ptr, wksp_ptr) pointer) 640 automatic; 641 642 declare 643 1 internal_buffer aligned automatic, 644 2 header like byte_buffer_header, 645 2 workspace aligned, 646 3 byte (0 : 255) bit (9) unaligned; 647 648 /* * * * * * * * * * * * * * * * * * * * * * * * */ 649 650 bv_err_code = ""b; 651 652 wksp_ptr = bv_buffer_ptr; 653 654 if SDB.string_ptr ^= null () 655 then do; 656 ext_buffer_ptr = SDB.string_ptr; 657 ext_wksp_ptr = addr (ext_buffer_ptr -> byte_buffer.byte); 658 659 num_elements = min (bv_num_elements, ext_buffer_ptr -> byte_buffer.num_bytes); 660 661 call copy_byte_array (addr (ext_wksp_ptr -> based_workspace.byte (ext_buffer_ptr -> byte_buffer.byte_offset)), addr (wksp_ptr -> based_workspace.byte (bv_first_offset)), num_elements); 662 663 ext_buffer_ptr -> byte_buffer.num_bytes = ext_buffer_ptr -> byte_buffer.num_bytes - num_elements; 664 ext_buffer_ptr -> byte_buffer.byte_offset = ext_buffer_ptr -> byte_buffer.byte_offset + num_elements; 665 666 if ext_buffer_ptr -> byte_buffer.num_bytes <= 0 667 then do; 668 SDB.string_ptr = null (); 669 670 free ext_buffer_ptr -> byte_buffer in (SDB.area_ptr -> based_area); 671 end; 672 673 bv_num_elements_trans = num_elements; 674 return; 675 end; 676 677 internal_buffer.header.info.area_ptr = null (); 678 internal_buffer.header.info.lock_word = ""b; 679 internal_buffer.header.buffer_bound = hbound (internal_buffer.workspace.byte, 1); 680 internal_buffer.header.byte_offset = 0; 681 internal_buffer.header.num_bytes = 0; 682 read_ptr = addr (internal_buffer); 683 684 err_code = error_table_$area_too_small; 685 do while (err_code = error_table_$area_too_small); 686 call read_from_telnet_interpreter (read_ptr, err_code); 687 if err_code = error_table_$area_too_small 688 then call make_bigger_buffer (read_ptr); 689 end; 690 691 if err_code ^= ""b 692 then do; 693 bv_err_code = err_code; 694 return; 695 end; 696 697 if read_ptr -> byte_buffer.num_bytes = 0 698 then do; 699 bv_num_elements_trans = 0; 700 bv_err_code = ""b; 701 return; 702 end; 703 704 wksp_ptr = bv_buffer_ptr; 705 first_offset = bv_first_offset; 706 num_to_read = bv_num_elements; 707 708 call copy_to_user_buffer (wksp_ptr, first_offset, num_to_read, num_elements, err_code); 709 if err_code = ""b 710 then do; 711 do n8 = first_offset by 1 to first_offset + num_elements - 1 712 while (^ SDB.read_delim_chars.delim (binary (wksp_ptr -> based_workspace.byte (n8), 9))); 713 end; 714 if n8 = first_offset + num_elements - 1 715 then do; 716 bv_num_elements_trans = num_elements; 717 718 call delete_buffer (read_ptr); 719 720 return; 721 end; 722 if n8 > first_offset + num_elements - 1 /* if there is no read delimiter, */ 723 then if connection_state ^= 6 /* then if the connection has been closed */ 724 then do; 725 bv_num_elements_trans = num_elements; 726 call delete_buffer (read_ptr); 727 return; 728 end; 729 end; 730 731 ext_buffer_ptr = null (); 732 733 err_code = error_table_$area_too_small; 734 do while (err_code = error_table_$area_too_small); 735 call make_bigger_buffer (ext_buffer_ptr); 736 737 call copy_to_user_buffer (addr (ext_buffer_ptr -> byte_buffer.byte), ext_buffer_ptr -> byte_buffer.byte_offset, ext_buffer_ptr -> byte_buffer.buffer_bound - ext_buffer_ptr -> byte_buffer.num_bytes, num_elements, err_code); 738 end; 739 740 if err_code ^= ""b 741 then do; 742 bv_err_code = err_code; 743 return; 744 end; 745 746 ext_buffer_ptr -> byte_buffer.num_bytes = ext_buffer_ptr -> byte_buffer.num_bytes + num_elements; 747 748 do n8 = ext_buffer_ptr -> byte_buffer.byte_offset by 1 to ext_buffer_ptr -> byte_buffer.byte_offset + ext_buffer_ptr -> byte_buffer.num_bytes - 1 749 while (^ SDB.read_delim_chars.delim (binary (ext_buffer_ptr -> byte_buffer.byte (n8), 9))); 750 end; 751 752 if n8 > ext_buffer_ptr -> byte_buffer.byte_offset + ext_buffer_ptr -> byte_buffer.num_bytes - 1 753 then return; 754 755 num_elements = n8 - ext_buffer_ptr -> byte_buffer.byte_offset + 1; 756 757 SDB.string_ptr = ext_buffer_ptr; 758 759 num_elements = min (num_elements, bv_num_elements); 760 761 wksp_ptr = bv_buffer_ptr; 762 call copy_byte_array (addr (ext_buffer_ptr -> byte_buffer.byte (ext_buffer_ptr -> byte_buffer.byte_offset)), addr (wksp_ptr -> based_workspace.byte (bv_first_offset)), num_elements); 763 764 ext_buffer_ptr -> byte_buffer.num_bytes = ext_buffer_ptr -> byte_buffer.num_bytes - num_elements; 765 ext_buffer_ptr -> byte_buffer.byte_offset = ext_buffer_ptr -> byte_buffer.byte_offset + num_elements; 766 767 bv_num_elements_trans = num_elements; 768 769 return; 770 771 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 772 773 copy_to_user_buffer: 774 procedure (bv_to_ptr, bv_to_offset, bv_num_to_read, bv_num_read, bv_error_code); 775 776 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 777 778 declare 779 ((bv_num_read, bv_num_to_read, bv_to_offset) fixed binary (24), 780 bv_error_code bit (36) aligned, 781 bv_to_ptr pointer) 782 parameter; 783 784 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * * */ 785 786 declare 787 ((from_count, from_offset) fixed binary (24), 788 dont_call_canonicalizer bit (1), 789 from_ptr pointer) 790 automatic; 791 792 /* * * * * * * * * * * * * * * * * * * * * * * * */ 793 794 dont_call_canonicalizer = "0"b; 795 796 if SDB.rawi 797 then dont_call_canonicalizer = "1"b; 798 799 if (^ SDB.can) & (^ SDB.erkl) & (^ SDB.esc) & (^ SDB.half) 800 then dont_call_canonicalizer = "1"b; 801 802 from_ptr = addr (read_ptr -> byte_buffer.byte); 803 from_offset = read_ptr -> byte_buffer.byte_offset; 804 from_count = read_ptr -> byte_buffer.num_bytes; 805 806 if dont_call_canonicalizer 807 then do; 808 if from_count > bv_num_to_read 809 then do; 810 bv_num_read = 0; 811 bv_error_code = error_table_$area_too_small; 812 813 return; 814 end; 815 816 call copy_byte_array (addr (from_ptr -> based_workspace.byte (from_offset)), addr (bv_to_ptr -> based_workspace.byte (bv_to_offset)), from_count); 817 818 bv_num_read = from_count; 819 820 bv_error_code = ""b; 821 return; 822 end; 823 824 call net_canonicalize_ (addr (SDB.canon_info), addr (from_ptr -> based_workspace.byte (from_offset)), from_count, 825 addr (bv_to_ptr -> based_workspace.byte (bv_to_offset)), bv_num_to_read, bv_num_read, bv_error_code); 826 827 return; 828 829 end copy_to_user_buffer; 830 831 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 832 833 end read_from_network; 834 835 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 836 837 read_from_telnet_interpreter: 838 procedure (bv_read_ptr, bv_error_code); 839 840 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 841 842 declare 843 (bv_error_code bit (36) aligned, 844 bv_read_ptr pointer) 845 parameter; 846 847 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 848 849 declare 850 (auto_byte_offset, raw_buff_count, read_byte_offset) fixed binary (24) 851 automatic; 852 853 declare 854 1 temp_device_state automatic aligned like device_state_template; 855 856 /* * * * * * * * * * * * * * * * * * * * * * * * */ 857 858 string (delimiter_array) = string (bv_SDB_ptr -> SDB_template.break_chars.break); 859 860 do while (bv_read_ptr -> byte_buffer.num_bytes = 0); 861 if (^ detected_a_break_condition (raw_buff_count, bv_error_code)) 862 then return; 863 864 read_byte_offset = bv_read_ptr -> byte_buffer.byte_offset + bv_read_ptr -> byte_buffer.num_bytes; 865 auto_byte_offset = SDB.rawbuffer_ptr -> byte_buffer.byte_offset; 866 867 unspec (temp_device_state) = unspec (bv_SDB_ptr -> SDB_template.device_state); 868 869 call net_convert_input_ (addr (temp_device_state), addr (SDB.rawbuffer_ptr -> byte_buffer.byte), 870 auto_byte_offset, SDB.rawbuffer_ptr -> byte_buffer.byte_offset + raw_buff_count - 1, 871 addr (bv_read_ptr -> byte_buffer.byte), read_byte_offset, bv_read_ptr -> byte_buffer.buffer_bound, bv_error_code); 872 if bv_error_code ^= ""b 873 then return; 874 875 if auto_byte_offset ^= SDB.rawbuffer_ptr -> byte_buffer.byte_offset + raw_buff_count 876 then do; 877 bv_error_code = error_table_$area_too_small; 878 return; 879 end; 880 881 unspec (bv_SDB_ptr -> SDB_template.device_state.terminal_state) = unspec (temp_device_state.terminal_state); 882 883 SDB.rawbuffer_ptr -> byte_buffer.byte_offset = SDB.rawbuffer_ptr -> byte_buffer.byte_offset + raw_buff_count; 884 SDB.rawbuffer_ptr -> byte_buffer.num_bytes = SDB.rawbuffer_ptr -> byte_buffer.num_bytes - raw_buff_count; 885 886 bv_read_ptr -> byte_buffer.num_bytes = read_byte_offset - bv_read_ptr -> byte_buffer.byte_offset; 887 end; 888 889 bv_error_code = ""b; 890 891 return; 892 893 end read_from_telnet_interpreter; 894 895 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 896 897 detected_a_break_condition: 898 procedure (bv_raw_count, bv_error_code) returns (bit (1) aligned); 899 900 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 901 902 declare 903 (bv_raw_count fixed binary (24), 904 bv_error_code bit (36) aligned) 905 parameter; 906 907 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 908 909 declare 910 ((n8, n8t, raw_hbound, raw_lbound) fixed binary (24), 911 found_a_break_char bit (1), 912 raw_buff_ptr pointer) 913 automatic; 914 915 /* * * * * * * * * * * * * * * * * * * * * * * * */ 916 917 bv_error_code = ""b; 918 919 bv_raw_count = 0; 920 921 found_a_break_char = "0"b; 922 do while (^ found_a_break_char); 923 raw_buff_ptr = SDB.rawbuffer_ptr; 924 raw_lbound = raw_buff_ptr -> byte_buffer.byte_offset; 925 raw_hbound = raw_lbound + raw_buff_ptr -> byte_buffer.num_bytes - 1; 926 927 do n8 = raw_lbound by 1 to raw_hbound 928 while ((raw_buff_ptr -> byte_buffer.byte (n8) ^= OUR_IAC) 929 & (^ delimiter_array (binary (raw_buff_ptr -> byte_buffer.byte (n8), 9)))); 930 end; 931 if (n8 <= raw_hbound) & (raw_buff_ptr -> byte_buffer.byte (n8) ^= OUR_IAC) 932 then found_a_break_char = "1"b; 933 else do; 934 if raw_buff_ptr -> byte_buffer.num_bytes = 0 935 then raw_buff_ptr -> byte_buffer.byte_offset = 0; 936 937 call read_from_ncp (n8t, bv_error_code); 938 if bv_error_code ^= ""b 939 then do; 940 if SDB.rawbuffer_ptr -> byte_buffer.num_bytes ^= 0 941 then do; 942 bv_raw_count = n8 + 1 - SDB.rawbuffer_ptr -> byte_buffer.byte_offset; 943 return ("1"b); 944 end; 945 return ("0"b); 946 end; 947 948 if n8t = 0 949 then return ("0"b); 950 951 if SDB.do_telnet 952 then do; 953 call net_telnet_interpreter_ (bv_SDB_ptr, SDB.rawbuffer_ptr, bv_error_code); 954 if bv_error_code = error_table_$ips_has_occurred 955 then do; 956 bv_error_code = ""b; 957 958 if have_machine_conditions 959 then call signal_ ("quit", bv_mc_ptr, null (), bv_crawlout_ptr); 960 else call signal_ ("quit", null (), null (), null ()); 961 end; 962 end; 963 end; 964 end; 965 966 bv_raw_count = n8 + 1 - SDB.rawbuffer_ptr -> byte_buffer.byte_offset; 967 968 bv_error_code = ""b; 969 970 return ("1"b); 971 972 end detected_a_break_condition; 973 974 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 975 976 read_from_ncp: 977 procedure (bv_num_elements_trans, bv_err_code); 978 979 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 980 981 declare 982 (bv_num_elements_trans fixed binary (24), 983 bv_err_code bit (36) aligned) 984 parameter; 985 986 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 987 988 declare 989 ((first_offset, indx, num_elements) fixed binary (24), 990 input_buffer (0 : 1099) bit (8), 991 previous_mask bit (36) aligned, 992 raw_buffer_ptr pointer, 993 transfer_proc variable entry (ptr, ptr, fixed bin (24), fixed bin (24), ptr, fixed bin (24), fixed bin (24), bit (36) aligned)) 994 automatic; 995 996 /* * * * * * * * * * * * * * * * * * * * * * * * */ 997 998 call hcs_$set_ips_mask (enable_mask, previous_mask); 999 1000 if SDB.rawbuffer_ptr -> byte_buffer.num_bytes = 0 1001 then do; 1002 call delete_buffer (SDB.rawbuffer_ptr); 1003 1004 SDB.rawbuffer_ptr = addr (SDB.initial_raw_buffer); 1005 SDB.rawbuffer_ptr -> byte_buffer.byte_offset = 0; 1006 SDB.rawbuffer_ptr -> byte_buffer.num_bytes = 0; 1007 end; 1008 1009 num_elements = 0; 1010 do while (num_elements < dimension (input_buffer, 1)); 1011 raw_buffer_ptr = SDB.rawbuffer_ptr; 1012 num_elements = raw_buffer_ptr -> byte_buffer.buffer_bound - (raw_buffer_ptr -> byte_buffer.byte_offset + raw_buffer_ptr -> byte_buffer.num_bytes); 1013 1014 if num_elements < dimension (input_buffer, 1) 1015 then call make_bigger_buffer (SDB.rawbuffer_ptr); 1016 end; 1017 1018 call net_$ncp_read (SDB.r_ncp_idx, addr (input_buffer), dimension (input_buffer, 1), 1019 bv_num_elements_trans, state, bv_err_code); 1020 if state ^= 6 & state ^= 11 1021 then connection_state = 1; /* connection has been closed */ 1022 1023 raw_buffer_ptr = SDB.rawbuffer_ptr; 1024 first_offset = raw_buffer_ptr -> byte_buffer.byte_offset + raw_buffer_ptr -> byte_buffer.num_bytes; 1025 indx = 0; 1026 if SDB.do_telnet 1027 then transfer_proc = net_convert_bytesize_$telnet_8_to_9; 1028 else transfer_proc = net_convert_bytesize_$direct_8_to_9; 1029 1030 call transfer_proc (null (), addr (input_buffer), indx, bv_num_elements_trans - 1, 1031 addr (raw_buffer_ptr -> byte_buffer.byte), first_offset, raw_buffer_ptr -> byte_buffer.buffer_bound, ((36)"0"b)); 1032 1033 raw_buffer_ptr -> byte_buffer.num_bytes = raw_buffer_ptr -> byte_buffer.num_bytes + bv_num_elements_trans; 1034 1035 call hcs_$set_ips_mask (previous_mask, ((36)"0"b)); 1036 1037 if bv_err_code ^= ""b 1038 then if bv_err_code ^= error_table_$area_too_small 1039 then return; 1040 1041 bv_err_code = ""b; 1042 1043 return; 1044 1045 end read_from_ncp; 1046 1047 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1048 1049 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1050 1051 copy_byte_array: 1052 procedure (bv_from_ptr, bv_to_ptr, bv_byte_count); 1053 1054 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 1055 1056 declare 1057 (bv_byte_count fixed binary (24), 1058 (bv_from_ptr, bv_to_ptr) pointer) 1059 parameter; 1060 1061 /* * * * * BASED & TEMPLATE DECLARATIONS * * * * */ 1062 1063 declare 1064 overlay_string bit (9 * bv_byte_count) 1065 based; 1066 1067 /* * * * * * * * * * * * * * * * * * * * * * * * */ 1068 1069 bv_to_ptr -> overlay_string = bv_from_ptr -> overlay_string; 1070 1071 return; 1072 1073 end copy_byte_array; 1074 1075 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1076 1077 make_bigger_buffer: 1078 procedure (bv_buffer_ptr); 1079 1080 /* * * * * PARAMETER DECLARATIONS * * * * * * * */ 1081 1082 declare 1083 bv_buffer_ptr pointer 1084 parameter; 1085 1086 /* * * * * AUTOMATIC STORAGE DECLARATIONS * * * */ 1087 1088 declare 1089 temp_ptr pointer 1090 automatic; 1091 1092 /* * * * * * * * * * * * * * * * * * * * * * * * */ 1093 1094 if bv_buffer_ptr = null () 1095 then buffer_allocation_size = 256; 1096 else buffer_allocation_size = 2 * bv_buffer_ptr -> byte_buffer.buffer_bound; 1097 1098 if SDB.area_ptr = null () 1099 then SDB.area_ptr = get_system_free_area_ (); 1100 1101 allocate byte_buffer in (SDB.area_ptr -> based_area) set (temp_ptr); 1102 temp_ptr -> byte_buffer.header.info.area_ptr = SDB.area_ptr; 1103 temp_ptr -> byte_buffer.header.lock_word = ""b; 1104 temp_ptr -> byte_buffer.byte_offset = 0; 1105 temp_ptr -> byte_buffer.num_bytes = 0; 1106 1107 if bv_buffer_ptr ^= null () 1108 then do; 1109 temp_ptr -> byte_buffer.num_bytes = bv_buffer_ptr -> byte_buffer.num_bytes; 1110 1111 call copy_byte_array (addr (bv_buffer_ptr -> byte_buffer.byte (bv_buffer_ptr -> byte_buffer.byte_offset)), addr (temp_ptr -> byte_buffer.byte (0)), temp_ptr -> byte_buffer.num_bytes); 1112 1113 if bv_buffer_ptr -> byte_buffer.header.info.area_ptr ^= null () 1114 then free bv_buffer_ptr -> byte_buffer in (bv_buffer_ptr -> byte_buffer.header.area_ptr -> based_area); 1115 end; 1116 1117 bv_buffer_ptr = temp_ptr; 1118 1119 return; 1120 1121 /* * * * * * * * * * * * * * * * * * * * * * * * */ 1122 1123 delete_buffer: 1124 entry (bv_buffer_ptr); 1125 1126 temp_ptr = bv_buffer_ptr; 1127 1128 bv_buffer_ptr = null (); 1129 1130 if temp_ptr = null () 1131 then return; 1132 1133 if temp_ptr -> byte_buffer.header.area_ptr = null () 1134 then return; 1135 1136 free temp_ptr -> byte_buffer in (temp_ptr -> byte_buffer.header.area_ptr -> based_area); 1137 1138 return; 1139 1140 end make_bigger_buffer; 1141 1142 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1143 1144 end net_ascii_dim_io_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/05/84 1328.8 net_ascii_dim_io_.pl1 >spec>temp>bce>40-00>net_ascii_dim_io_.pl1 157 1 12/15/83 1100.4 mc.incl.pl1 >ldd>include>mc.incl.pl1 158 2 09/23/77 1607.6 net_ascii_dim_sdb_dcls.incl.pl1 >ldd>include>net_ascii_dim_sdb_dcls.incl.pl1 2-105 3 09/23/77 1607.6 net_conversion_dcls.incl.pl1 >ldd>include>net_conversion_dcls.incl.pl1 159 4 05/06/74 1742.5 net_status_template.incl.pl1 >ldd>include>net_status_template.incl.pl1 160 5 06/01/84 1101.9 static_handlers.incl.pl1 >spec>temp>bce>40-00>static_handlers.incl.pl1 161 6 09/23/77 1607.5 telnet_options.incl.pl1 >ldd>include>telnet_options.incl.pl1 162 7 10/04/77 1919.0 telnet_special_chars.incl.pl1 >ldd>include>telnet_special_chars.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. IAC_DM 000001 constant bit(9) initial array unaligned dcl 106 set ref 438 438 IAC_GA 000000 constant bit(9) initial array unaligned dcl 106 set ref 328 328 366 366 OPEN_STATE constant fixed bin(6,0) initial dcl 102 ref 443 OPTION_suppress_ga constant fixed bin(8,0) initial dcl 6-8 ref 328 364 OUR_DM constant bit(9) initial unaligned dcl 7-30 ref 491 OUR_IAC 004240 constant bit(9) initial unaligned dcl 7-30 ref 927 931 OUR_NOP constant bit(9) initial unaligned dcl 7-30 ref 252 SDB defined structure level 1 dcl 77 set ref 185 185 502 502 SDB_template based structure level 1 dcl 2-14 set ref 174 174 181 181 185 185 185 185 204 204 211 211 218 218 223 223 224 224 230 230 241 241 246 246 252 252 252 252 253* 253 254* 254 255* 255 261 261 267 267 267 267 275 275 276 276 282 282 309* 309 313 313 319 319 326 326 328 328 328 328 335 335 347* 347 351 351 356 356 364 364 364 364 375* 375 389 389 404 404 412 412 414 414 414 414 415* 415 429* 429 431 431 436 436 439 439 442 442 479 479 481 481 486 486 488 488 502 502 502 502 540 540 540* 540 543 543 543 543 546 546 546 546 546 546 550* 550 550 550 552 552 552 552 552 552 552 552 552 552 552 552 556* 556 556 556 557* 557 557 557 582 582 582 582 585 585 591 591 612 612 654 654 656 656 668* 668 670 670 711 711 748 748 757* 757 796 796 799 799 799 799 799 799 799 799 824 824 824 824 865 865 869 869 869 869 869 869 875 875 883 883 883 883 884 884 884 884 923 923 940 940 942 942 951 951 953 953 966 966 1000 1000 1002 1002 1004* 1004 1004 1004 1005 1005 1006 1006 1011 1011 1014 1014 1018 1018 1023 1023 1026 1026 1098 1098 1098* 1098 1101 1101 1102 1102 TRANSMIT constant fixed bin(1,0) initial dcl 2-9 ref 328 364 aborting_output 134(01) defined bit(1) level 3 packed unaligned dcl 77 set ref 211 309* 347* 375* 429* actual_line 132 defined fixed bin(24,0) level 4 dcl 77 set ref 253* addr builtin function dcl 145 ref 185 185 267 267 267 267 276 276 328 328 366 366 438 438 502 502 546 546 552 552 587 587 587 587 614 614 614 614 657 661 661 661 661 682 737 737 762 762 762 762 802 816 816 816 816 824 824 824 824 824 824 869 869 869 869 869 869 1004 1018 1018 1030 1030 1030 1030 1111 1111 1111 1111 allow_quits 33(12) defined bit(1) level 4 packed unaligned dcl 77 set ref 481 area_ptr 1242 defined pointer level 2 in structure "SDB" dcl 77 in procedure "net_ascii_dim_io_" set ref 414 670 1098 1098* 1101 1102 area_ptr based pointer level 4 in structure "byte_buffer" dcl 90 in procedure "net_ascii_dim_io_" set ref 1102* 1113 1113 1133 1136 area_ptr 000660 automatic pointer level 4 in structure "internal_buffer" dcl 642 in procedure "read_from_network" set ref 677* attachment_info 136 defined structure level 2 dcl 77 auto_byte_offset 001012 automatic fixed bin(24,0) dcl 849 set ref 865* 869* 875 based_area based area(1024) dcl 82 ref 414 670 1101 1113 1136 based_workspace based structure level 1 dcl 86 binary builtin function dcl 145 ref 476 491 711 748 927 bit builtin function dcl 145 ref 476 break 44 based bit(1) array level 4 packed unaligned dcl 2-14 set ref 858 break_chars 44 based structure level 3 dcl 2-14 buffer2 000137 automatic char(1) array unaligned dcl 48 set ref 238 267 267 267 267 272 276 276 286 buffer_allocation_size 000106 automatic fixed bin(24,0) dcl 48 set ref 1094* 1096* 1101 1101 buffer_bound 3 000660 automatic fixed bin(24,0) level 3 in structure "internal_buffer" dcl 642 in procedure "read_from_network" set ref 679* buffer_bound 753 defined fixed bin(24,0) level 4 in structure "SDB" dcl 77 in procedure "net_ascii_dim_io_" set ref 546* buffer_bound 3 based fixed bin(24,0) level 3 in structure "byte_buffer" dcl 90 in procedure "net_ascii_dim_io_" set ref 414 670 737 869* 1012 1030* 1096 1101* 1113 1136 buffer_ptr 000570 automatic pointer dcl 522 set ref 532* 546* bv_SDB_ptr parameter pointer dcl 24 set ref 166 174 181 185 185 197 204 211 218 223 224 230 241 246 252 252 253 254 255 261 264* 267 267 275 276 282 303 309 313 319 326 328 328 328* 335 342 347 351 356 364 364 366* 375 384 389 404 412 414 414 415 424 429 431 436 438* 439 442 450 454* 456* 471 479 481 486 488 502 502 540 540 543 543 546 546 546 550 550 552 552 552 552 552 552 556 556 557 557 582 582 585 591 612 654 656 668 670 711 748 757 796 799 799 799 799 824 824 858 865 867 869 869 869 875 881 883 883 884 884 923 940 942 951 953* 953 966 1000 1002 1004 1004 1005 1006 1011 1014 1018 1023 1026 1098 1098 1101 1102 bv_buff_ptr parameter pointer dcl 513 ref 508 532 bv_buffer_ptr parameter pointer dcl 1082 in procedure "make_bigger_buffer" set ref 1077 1094 1096 1107 1109 1111 1111 1111 1111 1113 1113 1113 1117* 1123 1126 1128* bv_buffer_ptr parameter pointer dcl 629 in procedure "read_from_network" ref 624 652 704 761 bv_byte_count parameter fixed bin(24,0) dcl 1056 ref 1051 1069 1069 bv_condition_name parameter char unaligned dcl 24 ref 471 bv_continue_switch parameter bit(1) dcl 24 ref 471 bv_crawlout_ptr parameter pointer dcl 24 set ref 471 481* 958* bv_err_code parameter bit(36) dcl 513 in procedure "write_to_ncp" set ref 508 546* 552* 561 bv_err_code parameter bit(36) dcl 981 in procedure "read_from_ncp" set ref 976 1018* 1037 1037 1041* bv_err_code parameter bit(36) dcl 629 in procedure "read_from_network" set ref 624 650* 693* 700* 742* bv_error_code parameter bit(36) dcl 778 in procedure "copy_to_user_buffer" set ref 773 811* 820* 824* bv_error_code parameter bit(36) dcl 902 in procedure "detected_a_break_condition" set ref 897 917* 937* 938 953* 954 956* 968* bv_error_code parameter bit(36) dcl 842 in procedure "read_from_telnet_interpreter" set ref 837 861* 869* 872 877* 889* bv_external_data parameter bit(1) dcl 513 ref 508 534 bv_first_offset parameter fixed bin(24,0) dcl 513 in procedure "write_to_ncp" ref 508 531 bv_first_offset parameter fixed bin(24,0) dcl 629 in procedure "read_from_network" ref 624 661 661 705 762 762 bv_from_ptr parameter pointer dcl 1056 ref 1051 1069 bv_mc_ptr parameter pointer dcl 24 set ref 471 476 476 481* 958* bv_nelem parameter fixed bin(24,0) dcl 24 set ref 166 172 189 197 213 221 237 291 303 321* 342 359* bv_nelemt parameter fixed bin(24,0) dcl 24 set ref 166 189* 197 202* 213* 287* 291* 303 311* 321* 324 342 349* 358 359* 362 bv_num_elements parameter fixed bin(24,0) dcl 629 in procedure "read_from_network" ref 624 659 706 759 bv_num_elements parameter fixed bin(24,0) dcl 513 in procedure "write_to_ncp" ref 508 546 bv_num_elements_proc parameter fixed bin(24,0) dcl 513 set ref 508 549* bv_num_elements_trans parameter fixed bin(24,0) dcl 981 in procedure "read_from_ncp" set ref 976 1018* 1030 1033 bv_num_elements_trans parameter fixed bin(24,0) dcl 629 in procedure "read_from_network" set ref 624 673* 699* 716* 725* 767* bv_num_read parameter fixed bin(24,0) dcl 778 set ref 773 810* 818* 824* bv_num_to_read parameter fixed bin(24,0) dcl 778 set ref 773 808 824* bv_offset parameter fixed bin(24,0) dcl 24 set ref 166 171 197 220 235 303 321* 342 359* bv_old_status parameter structure level 1 dcl 39 ref 450 bv_raw_ ----------------------------------------------------------- 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