*copyc OSD$DEFAULT_PRAGMATS
MODULE iim$store_term_conn_attributes;
?? TITLE := 'MODULE iim$store_term_conn_attributes' ??

?? PUSH (LISTEXT := ON) ??
*copyc AMP$CLOSE
*copyc AMP$FETCH
*copyc BAP$VALIDATE_FILE_IDENTIFIER
*copyc CLP$GET_ULTIMATE_CONNECTION
*copyc CLP$VALIDATE_NAME
*copyc CLV$STANDARD_FILES
*copyc IFE$ERROR_CODES
*copyc IFT$CONNECTION_ATTRIBUTES
*copyc IIP$CONNECTION_TO_VT_ATTRIBUTES
*copyc iik$keypoints
*copyc iip$search_connection_desc
*copyc iip$st_update_actual_attributes
*copyc iip$st_flush
*copyc IIT$CONNECTION_DESCRIPTION
*copyc IIV$INTERACTIVE_TERMINATED
*copyc jmp$system_job
*copyc OST$STATUS
*copyc OSP$APPEND_STATUS_INTEGER
*copyc OSP$APPEND_STATUS_PARAMETER
*copyc OSP$SET_STATUS_ABNORMAL
*copyc PMP$GET_JOB_MODE
*copyc RMP$GET_DEVICE_CLASS
?? POP ??

?? NEWTITLE := 'PROCEDURE iip$store_term_conn_attributes', EJECT ??

  PROCEDURE [XDCL, #GATE] iip$store_term_conn_attributes (file_id: amt$file_identifier;
        open_file_desc_pointer: ^iit$st_open_file_description;
        connection_attributes: ^ift$connection_attributes;
    VAR status: ost$status);

    VAR
      connection_desc_ptr: ^iit$connection_description,
      converted_name: amt$local_file_name,
      device_assigned: boolean,
      device_class: rmt$device_class,
      device_is_network: boolean,
      fetch_attributes: array [1 .. 1] of amt$fetch_item,
      file_identifier: amt$file_identifier,
      file_id_is_valid: boolean,
      file_instance: ^bat$task_file_entry,
      i: integer,
      j: integer,
      job_mode: jmt$job_mode,
      k: integer,
      local_status: ost$status,
      ofdp: ^iit$st_open_file_description,
      replacing_prompt_file_id: boolean,
      response_received: boolean,
      set_of_input_editing_modes: iit$set_of_input_editing_modes,
      set_of_input_output_modes: iit$set_of_input_output_modes,
      set_of_term_conn_attribute_keys: iit$set_of_term_conn_attr_keys,
      set_of_trans_char_modes: iit$set_of_trans_char_modes,
      set_of_trans_length_modes: iit$set_of_trans_length_modes,
      set_of_trans_protocol_modes: iit$set_of_trans_protocol_modes,
      set_of_trans_timeout_modes: iit$set_of_trans_timeout_modes,
      ultimate_name: amt$local_file_name,
      ultimate_prompt_file: amt$local_file_name,
      valid_name: boolean;

    status.normal := TRUE;
    replacing_prompt_file_id := FALSE;
    file_identifier := file_id;

*copy bai$validate_file_identifier

{ Verify that the terminal file exists and that it is a network file.

    device_is_network := (file_instance^.device_class = rmc$network_device) OR
            (file_instance^.device_class = rmc$terminal_device);

    IF NOT device_is_network THEN
      clp$get_ultimate_connection (file_instance^.local_file_name, ultimate_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      pmp$get_job_mode (job_mode, local_status);
      IF NOT local_status.normal THEN
        status := local_status;
        RETURN;
      ELSEIF (NOT (job_mode IN $iit$job_modes [jmc$interactive_connected,
             jmc$interactive_cmnd_disconnect, jmc$interactive_line_disconnect,
             jmc$interactive_sys_disconnect]) AND
             (((ultimate_name = clv$standard_files [clc$sf_job_input_file].path_handle_name) OR
             (ultimate_name = clv$standard_files [clc$sf_job_output_file].path_handle_name)) OR
             (ultimate_name = clv$standard_files [clc$sf_command_file].path_handle_name))) THEN
        osp$set_status_abnormal (ifc$interactive_facility_id,
             ife$current_job_not_interactive, 'IIP$STORE_TERM_CONN_ATTRIBUTES',
             status);
        RETURN;
      ELSE
        osp$set_status_abnormal (ifc$interactive_facility_id,
            ife$file_name_not_terminal, converted_name, status);
        RETURN;
      IFEND;
    IFEND;

{ Validate the connection attribute keys and the OS-defined attribute values
{ for prompt_file, prompt_file_id, prompt_string, input_timeout, input_timeout_purge,
{ input_timeout_length, and end_of_information.

    set_of_term_conn_attribute_keys := - $iit$set_of_term_conn_attr_keys [];
    FOR i := LOWERBOUND (connection_attributes^) TO UPPERBOUND
          (connection_attributes^) DO
      IF NOT (connection_attributes^ [i].key IN set_of_term_conn_attribute_keys)
            THEN
        osp$set_status_abnormal (ifc$interactive_facility_id,
              ife$unknown_attribute_key, '', status);
        k := ORD (connection_attributes^ [i].key);
        osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
              FALSE, status);
        osp$append_status_parameter (osc$status_parameter_delimiter,
          'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
        RETURN;
      IFEND;
      CASE connection_attributes^ [i].key OF

      = ifc$attention_character_action =

        k := connection_attributes^ [i].attention_character_action;
        IF ((k < LOWERVALUE (ift$attention_character_action)) OR (k >
              UPPERVALUE (ift$attention_character_action))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$attention_character_action, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$attention_character_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$attention_character_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$break_key_action =

        k := connection_attributes^ [i].break_key_action;
        IF ((k < LOWERVALUE (ift$break_key_action)) OR (k >
              UPPERVALUE (ift$break_key_action))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$break_key_action, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$break_key_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$break_key_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$end_of_information =

        k := connection_attributes^ [i].end_of_information.size;
        IF ((k < LOWERVALUE (ift$end_of_information_size)) OR (k > UPPERVALUE
              (ift$end_of_information_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$end_of_information_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$end_of_information_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$end_of_information_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$input_block_size =

        k := connection_attributes^ [i].input_block_size;
        IF ((k < LOWERVALUE (ift$input_block_size)) OR (k > UPPERVALUE
              (ift$input_block_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_block_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$input_block_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$input_block_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$input_editing_mode =

        set_of_input_editing_modes := - $iit$set_of_input_editing_modes [];
        IF NOT (connection_attributes^ [i].input_editing_mode IN set_of_input_editing_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_input_editing_mode, '', status);
          k := ORD (connection_attributes^ [i].input_editing_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$input_output_mode =

        set_of_input_output_modes := - $iit$set_of_input_output_modes [];
        IF NOT (connection_attributes^ [i].input_output_mode IN set_of_input_output_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_input_output_mode, '', status);
          k := ORD (connection_attributes^ [i].input_output_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$input_timeout =

        IF ((connection_attributes^ [i].input_timeout < LOWERVALUE
              (boolean)) OR (connection_attributes^ [i].input_timeout >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_timeout, 'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$input_timeout_length =

        k := connection_attributes^ [i].input_timeout_length;
        IF ((k < LOWERVALUE (ift$input_timeout_length)) OR (k > UPPERVALUE
              (ift$input_timeout_length))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_timeout_length, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$input_timeout_length);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$input_timeout_length);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$input_timeout_purge =

        IF ((connection_attributes^ [i].input_timeout_purge < LOWERVALUE
              (boolean)) OR (connection_attributes^ [i].input_timeout_purge >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_timeout_purge, 'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$partial_char_forwarding =

        IF ((connection_attributes^ [i].partial_character_forwarding < LOWERVALUE
              (boolean)) OR (connection_attributes^ [i].partial_character_forwarding >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$partial_char_forwarding, 'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$prompt_file =

        clp$get_ultimate_connection (connection_attributes^ [i].prompt_file, ultimate_prompt_file, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

{ Verify that the file is assigned to a terminal device.

        rmp$get_device_class (ultimate_prompt_file, device_assigned, device_class, local_status);
        IF NOT local_status.normal THEN
          status := local_status;
          RETURN;
        ELSE
          IF NOT device_assigned THEN
            osp$set_status_abnormal (ifc$interactive_facility_id,
                  ife$prompt_file_name_not_found, ultimate_prompt_file, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
              'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
            RETURN;
          ELSEIF device_class <> rmc$terminal_device THEN
            osp$set_status_abnormal (ifc$interactive_facility_id,
                  ife$prompt_file_name_not_term, ultimate_prompt_file, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
              'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
            RETURN;
          IFEND;
        IFEND;

      = ifc$prompt_file_identifier =

{ Get the file_name for the file_id.

{ The following code is no-op'ed until BAM provides a way to obtain
{ the local_file_name given the file_id.

{       fetch_attributes [1].key := amc$local_file_name;
{       amp$fetch (connection_attributes^ [i].prompt_file_identifier, fetch_attributes,
{             local_status);
{       IF NOT local_status.normal THEN
{         status := local_status;
{         RETURN;
{       IFEND;
{
{ Verify that the file is assigned to a terminal device.
{
{       rmp$get_device_class (fetch_attributes [1].file_name^.local_file_name,
{             device_assigned, device_class, local_status);
{       IF NOT local_status.normal THEN
{         status := local_status;
{         RETURN;
{       ELSE
{         IF NOT device_assigned THEN
{           osp$set_status_abnormal (ifc$interactive_facility_id,
{                 ife$prompt_file_id_not_found, fetch_attributes [1].
{                 file_name^.local_file_name, status);
{           osp$append_status_parameter (osc$status_parameter_delimiter,
{             'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
{           RETURN;
{         ELSEIF device_class <> rmc$terminal_device THEN
{           osp$set_status_abnormal (ifc$interactive_facility_id,
{                 ife$prompt_file_id_not_term, fetch_attributes [1].file_name^.
{                 local_file_name, status);
{           osp$append_status_parameter (osc$status_parameter_delimiter,
{             'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
{           RETURN;
{         IFEND;
{       IFEND;

      = ifc$prompt_string =

        k := connection_attributes^ [i].prompt_string.size;
        IF ((k < LOWERVALUE (ift$prompt_string_size)) OR (k > UPPERVALUE
              (ift$prompt_string_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$prompt_string_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$prompt_string_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$prompt_string_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$store_backspace_character =

        IF ((connection_attributes^ [i].store_backspace_character < LOWERVALUE
              (boolean)) OR (connection_attributes^ [i].store_backspace_character >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$store_backspace_character, 'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$store_nuls_dels =

        IF ((connection_attributes^ [i].store_nuls_dels < LOWERVALUE
              (boolean)) OR (connection_attributes^ [i].store_nuls_dels >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$store_nuls_dels, 'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$trans_character_mode =

        set_of_trans_char_modes := - $iit$set_of_trans_char_modes [];
        IF NOT (connection_attributes^ [i].trans_character_mode IN set_of_trans_char_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_char_mode, '', status);
          k := ORD (connection_attributes^ [i].trans_character_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$trans_length_mode =

        set_of_trans_length_modes := - $iit$set_of_trans_length_modes [];
        IF NOT (connection_attributes^ [i].trans_length_mode IN set_of_trans_length_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_length_mode, '', status);
          k := ORD (connection_attributes^ [i].trans_length_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$trans_timeout_mode =

        set_of_trans_timeout_modes := - $iit$set_of_trans_timeout_modes [];
        IF NOT (connection_attributes^ [i].trans_timeout_mode IN set_of_trans_timeout_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_timeout_mode, '', status);
          k := ORD (connection_attributes^ [i].trans_timeout_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$trans_forward_character =

        k := connection_attributes^ [i].trans_forward_character.size;
        IF ((k < LOWERVALUE (ift$trans_fwd_char_size)) OR (k > UPPERVALUE
              (ift$trans_fwd_char_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$trans_fwd_character_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$trans_fwd_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$trans_fwd_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$trans_message_length =

        k := connection_attributes^ [i].trans_message_length;
        IF ((k < LOWERVALUE (ift$trans_message_length)) OR (k > UPPERVALUE
              (ift$trans_message_length))) THEN
          IF k <> 0 THEN
            osp$set_status_abnormal (ifc$interactive_facility_id,
                  ife$trans_message_length, '', status);
            osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                  FALSE, status);
            k := LOWERVALUE (ift$trans_message_length);
            osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                  FALSE, status);
            k := UPPERVALUE (ift$trans_message_length);
            osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                  FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
              'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
            RETURN;
          IFEND;
        IFEND;

      = ifc$trans_terminate_character =

        k := connection_attributes^ [i].trans_terminate_character.size;
        IF ((k < LOWERVALUE (ift$trans_term_char_size)) OR (k > UPPERVALUE
              (ift$trans_term_char_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$trans_term_character_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$trans_term_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$trans_term_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      = ifc$trans_protocol_mode =

        set_of_trans_protocol_modes := - $iit$set_of_trans_protocol_modes [];
        IF NOT (connection_attributes^ [i].trans_protocol_mode IN set_of_trans_protocol_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_protocol_mode, '', status);
          k := ORD (connection_attributes^ [i].trans_protocol_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$STORE_TERM_CONN_ATTRIBUTES', status);
          RETURN;
        IFEND;

      ELSE
      CASEND;
    FOREND;

    IF replacing_prompt_file_id AND ((open_file_desc_pointer^.attributes.
          prompt_file_identifier.value.ordinal <> 0) AND
         (open_file_desc_pointer^.attributes.prompt_file_identifier.source =
         ifc$os_default)) THEN
      amp$close (open_file_desc_pointer^.attributes.prompt_file_identifier.value, local_status);
    IFEND;

{ Update the attributes in the open file descriptor.

    ofdp := open_file_desc_pointer;
    FOR j := 1 TO UPPERBOUND (connection_attributes^) DO
      CASE connection_attributes^ [j].key OF
      = ifc$attention_character_action =
        ofdp^.attributes.attention_character_action.value :=
              connection_attributes^ [j].attention_character_action;
        ofdp^.attributes.attention_character_action.source := ifc$store_term_conn_request;
      = ifc$break_key_action =
        ofdp^.attributes.break_key_action.value :=
              connection_attributes^ [j].break_key_action;
        ofdp^.attributes.break_key_action.source := ifc$store_term_conn_request;
      = ifc$end_of_information =
        ofdp^.attributes.end_of_information.value :=
              connection_attributes^ [j].end_of_information;
        ofdp^.attributes.end_of_information.source := ifc$store_term_conn_request;
      = ifc$input_block_size =
        ofdp^.attributes.input_block_size.value :=
              connection_attributes^ [j].input_block_size;
        ofdp^.attributes.input_block_size.source := ifc$store_term_conn_request;
      = ifc$input_editing_mode =
        ofdp^.attributes.input_editing_mode.value :=
              connection_attributes^ [j].input_editing_mode;
        ofdp^.attributes.input_editing_mode.source := ifc$store_term_conn_request;
      = ifc$input_output_mode =
        ofdp^.attributes.input_output_mode.value :=
              connection_attributes^ [j].input_output_mode;
        ofdp^.attributes.input_output_mode.source := ifc$store_term_conn_request;
      = ifc$input_timeout =
        ofdp^.attributes.input_timeout.value :=
              connection_attributes^ [j].input_timeout;
        ofdp^.attributes.input_timeout.source := ifc$store_term_conn_request;
      = ifc$input_timeout_length =
        ofdp^.attributes.input_timeout_length.value :=
              connection_attributes^ [j].input_timeout_length;
        ofdp^.attributes.input_timeout_length.source := ifc$store_term_conn_request;
      = ifc$input_timeout_purge =
        ofdp^.attributes.input_timeout_purge.value :=
              connection_attributes^ [j].input_timeout_purge;
        ofdp^.attributes.input_timeout_purge.source := ifc$store_term_conn_request;
      = ifc$partial_char_forwarding =
        ofdp^.attributes.partial_char_forwarding.value :=
              connection_attributes^ [j].partial_character_forwarding;
        ofdp^.attributes.partial_char_forwarding.source := ifc$store_term_conn_request;
      = ifc$prompt_file =
        ofdp^.attributes.prompt_file.value :=
              connection_attributes^ [j].prompt_file;
        ofdp^.attributes.prompt_file.source := ifc$store_term_conn_request;
      = ifc$prompt_file_identifier =
        ofdp^.attributes.prompt_file_identifier.value :=
              connection_attributes^ [j].prompt_file_identifier;
        ofdp^.attributes.prompt_file_identifier.source := ifc$store_term_conn_request;
      = ifc$prompt_string =
        ofdp^.attributes.prompt_string.value :=
              connection_attributes^ [j].prompt_string;
        ofdp^.attributes.prompt_string.source := ifc$store_term_conn_request;
      = ifc$store_backspace_character =
        ofdp^.attributes.store_backspace_character.value :=
              connection_attributes^ [j].store_backspace_character;
        ofdp^.attributes.store_backspace_character.source := ifc$store_term_conn_request;
      = ifc$store_nuls_dels =
        ofdp^.attributes.store_nuls_dels.value :=
              connection_attributes^ [j].store_nuls_dels;
        ofdp^.attributes.store_nuls_dels.source := ifc$store_term_conn_request;
      = ifc$trans_character_mode =
        ofdp^.attributes.trans_character_mode.value :=
              connection_attributes^ [j].trans_character_mode;
        ofdp^.attributes.trans_character_mode.source := ifc$store_term_conn_request;
      = ifc$trans_forward_character =
        ofdp^.attributes.trans_forward_character.value :=
              connection_attributes^ [j].trans_forward_character;
        ofdp^.attributes.trans_forward_character.source := ifc$store_term_conn_request;
      = ifc$trans_length_mode =
        ofdp^.attributes.trans_length_mode.value :=
              connection_attributes^ [j].trans_length_mode;
        ofdp^.attributes.trans_length_mode.source := ifc$store_term_conn_request;
      = ifc$trans_timeout_mode =
        ofdp^.attributes.trans_timeout_mode.value :=
              connection_attributes^ [j].trans_timeout_mode;
        ofdp^.attributes.trans_timeout_mode.source := ifc$store_term_conn_request;
      = ifc$trans_message_length =
        ofdp^.attributes.trans_message_length.value :=
              connection_attributes^ [j].trans_message_length;
        ofdp^.attributes.trans_message_length.source := ifc$store_term_conn_request;
      = ifc$trans_terminate_character =
        ofdp^.attributes.trans_terminate_character.value :=
              connection_attributes^ [j].trans_terminate_character;
        ofdp^.attributes.trans_terminate_character.source := ifc$store_term_conn_request;
      = ifc$trans_protocol_mode =
        ofdp^.attributes.trans_protocol_mode.value :=
              connection_attributes^ [j].trans_protocol_mode;
        ofdp^.attributes.trans_protocol_mode.source := ifc$store_term_conn_request;
      ELSE
        {}
      CASEND;
    FOREND;
{ Update access information.

      ofdp^.last_access_operation := ifc$store_terminal_req;



  PROCEND iip$store_term_conn_attributes;

MODEND iim$store_term_conn_attributes;
