?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE NETWORK ACCESS : Generic Transport Application Layer' ??
MODULE nam$external_gt_interface;
?? NEWTITLE := 'Global Declarations Referenced by This Module' ??
?? PUSH (LISTEXT := ON) ??
*copyc nae$application_interfaces
*copyc nae$namve_conditions
*copyc nat$gt_connection
*copyc nat$gt_connection_options
*copyc nat$gt_destination_address
*copyc nat$gt_event
*copyc nat$gt_interface
*copyc nat$gt_job_connection
*copyc nat$gt_job_sap
*copyc nat$gt_sap
*copyc nat$gt_sap_identifier
*copyc nat$gt_wait_list
*copyc nat$internet_address
*copyc nat$maximum_active_connections
*copyc nat$network_address
*copyc nat$network_message_priority
*copyc nat$ta_alternate_protocol_class
*copyc nat$ta_preferred_protocol_class
*copyc nlt$ta_event
*copyc nlt$ta_sap_selector
*copyc oss$network_paged
*copyc oss$job_paged_literal
*copyc ost$activity_status
*copyc ost$wait
?? POP ??
*copyc osp$append_status_parameter
*copyc nap$condition_handler_trace
*copyc nap$gt_add_job_sap
*copyc nap$gt_clear_exclusive_to_clist
*copyc nap$gt_clear_exclusive_to_slist
*copyc nap$gt_create_job_connection
*copyc nap$gt_deactivate_job_connect
*copyc nap$gt_delete_job_connection
*copyc nap$gt_delete_job_sap
*copyc nap$gt_get_exclusive_to_clist
*copyc nap$gt_get_exclusive_to_slist
*copyc nap$gt_releas_exclusiv_to_clist
*copyc nap$gt_releas_exclusiv_to_slist
*copyc nlp$al_deliver_data
*copyc nlp$al_fragment_data
*copyc nlp$al_get_data_length
*copyc nlp$al_get_data_requirements
*copyc nlp$al_initialize_data_descrip
*copyc nlp$bm_concatenate_messages
*copyc nlp$bm_copy_message
*copyc nlp$bm_create_message
*copyc nlp$bm_get_message_length
*copyc nlp$bm_get_message_resources
*copyc nlp$bm_release_message
*copyc nlp$cancel_timer
*copyc nlp$cl_activate_layer
*copyc nlp$cl_activate_receiver
*copyc nlp$cl_activate_sender
*copyc nlp$cl_clear_exclusive_access
*copyc nlp$cl_create_connection
*copyc nlp$cl_deactivate_layer
*copyc nlp$cl_deactivate_receiver
*copyc nlp$cl_deactivate_sender
*copyc nlp$cl_get_connection_processor
*copyc nlp$cl_get_exclusive_via_cid
*copyc nlp$cl_get_layer_connection
*copyc nlp$cl_get_sap_processor
*copyc nlp$cl_initialize_template
*copyc nlp$cl_release_exclusive_access
*copyc nlp$osi_get_outbound_capacity
*copyc nlp$select_timer
*copyc nlp$ta_accept_connection
*copyc nlp$ta_close_sap
*copyc nlp$ta_disconnect_connection
*copyc nlp$ta_initialize
*copyc nlp$ta_open_sap
*copyc nlp$ta_report_undelivered_data
*copyc nlp$ta_request_connection
*copyc nlp$ta_send_data
*copyc nlp$ta_send_expedited_data
*copyc nlp$timer_expired
*copyc osp$append_status_integer
*copyc osp$begin_subsystem_activity
*copyc osp$clear_job_signature_lock
*copyc osp$disestablish_cond_handler
*copyc osp$end_subsystem_activity
*copyc osp$establish_block_exit_hndlr
*copyc osp$establish_condition_handler
*copyc osp$push_inhibit_job_recovery
*copyc osp$pop_inhibit_job_recovery
*copyc osp$set_job_signature_lock
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$set_status_from_condition
*copyc osp$test_sig_lock
*copyc pmp$continue_to_cause
*copyc pmp$get_executing_task_gtid
*copyc pmp$send_signal
*copyc pmp$wait
*copyc syp$cycle
*copyc nav$network_paged_heap
*copyc nav$namve_active
*copyc nav$gt_assigned_sap_list
*copyc nav$gt_sap_list
*copyc nav$gt_job_sap_list
*copyc nav$gt_job_connection_list
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  CONST
    nac$gt_accept_timer_duration = (5 * 60 * 1000 * 1000), { microseconds }
    nac$gt_event_timer_duration = (8 * 60 * 1000 * 1000), { microseconds }
    nac$gt_maximum_connect_data = 32,
    nac$gt_maximum_accept_data = 32,
    nac$gt_maximum_expedited_data = 16,
    nac$gt_maximum_disconnect_data = 64,
    nac$gt_sap_event_timer_duration = (5 * 60 * 1000 * 1000); { microseconds }

  TYPE
    nat$gt_condition_cause = (nac$gt_application_data, nac$gt_application_event, nac$gt_activity_status,
          nac$gt_request_not_cause, nac$gt_task_termination);


  VAR
    nav$gt_null_sap: [STATIC, READ, oss$job_paged_literal] nat$gt_sap :=
          [ * , NIL, NIL, [FALSE], [FALSE, * , NIL, NIL, [nac$gt_fixed,
          [0, 0, [REP nac$gt_fixed_fragments of [NIL, 0]]]]], [NIL, NIL], FALSE],

    nav$gt_null_connect_rq_receiver: [STATIC, READ, oss$job_paged_literal]
          nat$gt_connect_request_receiver := [FALSE, * , NIL, NIL,
          [nac$gt_fixed, [0, 0, [REP nac$gt_fixed_fragments of [NIL, 0]]]]],

    nav$gt_null_connection: [STATIC, READ, oss$job_paged_literal] nat$gt_connection :=
          [nac$gt_closed, * , * , 0, [FALSE], [NIL, NIL], [NIL, FALSE, 0,
          [nac$gt_fixed, [0, 0, [REP nac$gt_fixed_fragments of [NIL, 0]]]]],
          [NIL, NIL, 0, FALSE, 0, [nac$gt_fixed, [0, 0, [REP nac$gt_fixed_fragments of [NIL, 0]]]]]],

    nav$gt_null_sender_request: [STATIC, READ, oss$job_paged_literal] nat$gt_sender_request :=
          [NIL, FALSE, 0, [nac$gt_fixed, [0, 0, [REP nac$gt_fixed_fragments of [NIL, 0]]]]],

    nav$gt_null_receiver_request: [STATIC, READ, oss$job_paged_literal] nat$gt_receiver_request :=
          [NIL, NIL, 0, FALSE, 0, [nac$gt_fixed, [0, 0, [REP nac$gt_fixed_fragments of [NIL, 0]]]]],

    nav$gt_null_message: [STATIC, READ, oss$job_paged_literal] array
          [1 .. 1] of nat$data_fragment := [[NIL, 0]],

    external_interface: [STATIC, READ, oss$job_paged_literal] string (36) :=
          'GENERIC TRANSPORT EXTERNAL INTERFACE';

?? OLDTITLE ??
?? NEWTITLE := 'Global Debug Declarations', EJECT ??
*copyc osp$decrement_locked_variable
*copyc osp$increment_locked_variable
*copyc nav$debug_mode

  VAR
    nav$multiple_namve_hndler_calls: [XREF] integer,
    nav$namve_tsk_hndl_active_count: [XREF] integer;

?? OLDTITLE ??
?? NEWTITLE := 'assign_sap_identifier', EJECT ??

  PROCEDURE assign_sap_identifier
    (    reserved_sap: boolean;
         selector: nlt$ta_sap_selector;
         shared_sap: boolean;
     VAR sap_identifier: nlt$ta_sap_selector;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    osp$set_job_signature_lock (nav$gt_assigned_sap_list.lock);
    IF reserved_sap THEN
      IF ((selector >= nlc$ta_min_rsvd_transport_sap) AND (selector <= nlc$ta_max_rsvd_transport_sap)) OR
         ((selector >= nlc$ta_mhs_min_transport_sap)  AND (selector <= nlc$ta_mhs_max_transport_sap))  OR
         ((selector >= nlc$ta_ftam_min_transport_sap) AND (selector <= nlc$ta_ftam_max_transport_sap)) OR
         ((selector >= nlc$ta_low_min_osi_sap) AND (selector <= nlc$ta_low_max_osi_sap)) THEN
        IF nav$gt_assigned_sap_list.sap [selector] = nac$gt_unassigned THEN
          nav$gt_assigned_sap_list.sap [selector] := nac$gt_assigned;
          sap_identifier := selector;
        ELSEIF shared_sap THEN
          /search_for_a_free_sap/
          BEGIN
            FOR i := nlc$ta_min_transport_sap TO UPPERBOUND (nav$gt_assigned_sap_list.sap) DO
              IF nav$gt_assigned_sap_list.sap [i] = nac$gt_unassigned THEN
                nav$gt_assigned_sap_list.sap [i] := nac$gt_assigned;
                sap_identifier := i;
                EXIT /search_for_a_free_sap/;
              IFEND;
            FOREND;
            osp$set_status_condition ( nae$maximum_saps_open,  status);
          END /search_for_a_free_sap/;
        ELSE
          osp$set_status_condition ( nae$sap_already_open,  status);
          osp$append_status_integer (osc$status_parameter_delimiter, selector, 10, TRUE, status);
        IFEND;
      ELSE { invalid reserved sap identifier
        osp$set_status_condition ( nae$invalid_reserved_sap,  status);
      IFEND;
    ELSE { non reserved sap

    /search_for_available_sap/
      BEGIN
        FOR i := nlc$ta_min_transport_sap TO UPPERBOUND (nav$gt_assigned_sap_list.sap) DO
          IF nav$gt_assigned_sap_list.sap [i] = nac$gt_unassigned THEN
            nav$gt_assigned_sap_list.sap [i] := nac$gt_assigned;
            sap_identifier := i;
            EXIT /search_for_available_sap/;
          IFEND;
        FOREND;
        osp$set_status_condition ( nae$maximum_saps_open,  status);
      END /search_for_available_sap/;
    IFEND;
    osp$clear_job_signature_lock (nav$gt_assigned_sap_list.lock);
  PROCEND assign_sap_identifier;
?? OLDTITLE ??
?? NEWTITLE := 'unassign_sap_identifier', EJECT ??

  PROCEDURE unassign_sap_identifier
    (    sap_identifier: nlt$ta_sap_selector);

    osp$set_job_signature_lock (nav$gt_assigned_sap_list.lock);
    IF (sap_identifier >= LOWERBOUND (nav$gt_assigned_sap_list.sap)) AND
          (sap_identifier <= UPPERBOUND (nav$gt_assigned_sap_list.sap)) THEN
      nav$gt_assigned_sap_list.sap [sap_identifier] := nac$gt_unassigned;
    IFEND;
    osp$clear_job_signature_lock (nav$gt_assigned_sap_list.lock);
  PROCEND unassign_sap_identifier;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_accept_connection', EJECT ??
*copy nah$gt_accept_connection

  PROCEDURE [XDCL, #GATE] nap$gt_accept_connection
    (    connection_id: nat$gt_connection_id,
         data: nat$data_fragments;
         options: ^nat$gt_connection_options;
     VAR status: ost$status);

    VAR
      cl_connection: ^nlt$cl_connection;

?? NEWTITLE := 'terminate_accept_connection', EJECT ??

    PROCEDURE terminate_accept_connection
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        nlp$cl_clear_exclusive_access (cl_connection);
        osp$pop_inhibit_job_recovery;
        osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
        EXIT nap$gt_accept_connection;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_accept_connection;
?? OLDTITLE, EJECT ??

    VAR
      checksum: boolean,
      connection: ^nat$gt_connection,
      data_length: nat$data_length,
      expedited_data: boolean,
      message_id: nlt$bm_message_id,
      i: integer,
      internal_status: ost$status;

    status.normal := TRUE;

    IF UPPERBOUND (data) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_length (data, data_length);
    IF data_length <= nac$gt_maximum_accept_data THEN
      osp$push_inhibit_job_recovery;
      get_connection_access (connection_id, cl_connection, connection, internal_status);
      IF internal_status.normal THEN
        IF connection^.state = nac$gt_connect_req_delivered THEN
          nlp$cancel_timer (connection^.timer);
          osp$establish_condition_handler (^terminate_accept_connection, FALSE);
          nlp$bm_create_message (data, message_id, internal_status);
          osp$disestablish_cond_handler;
          checksum := FALSE;
          expedited_data := FALSE;
          IF options <> NIL THEN
            FOR i := LOWERBOUND (options^) TO UPPERBOUND (options^) DO
              CASE options^ [i].kind OF
              = nac$gt_checksum =
                checksum := options^ [i].checksum;
              = nac$gt_expedited_data =
                expedited_data := options^ [i].expedited_data;
              ELSE
              CASEND;
            FOREND;
          IFEND;
          nap$gt_get_exclusive_to_slist;
          nlp$ta_accept_connection (cl_connection, checksum, message_id, expedited_data,
                sap_priority (connection^.sap_id), {quality_of_service = } NIL, internal_status);
          nap$gt_releas_exclusiv_to_slist;
          IF internal_status.normal THEN
            connection^.state := nac$gt_open;
          IFEND;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$connection_not_proposed, external_interface,
                internal_status);
        IFEND;
        nlp$cl_release_exclusive_access (cl_connection);
        osp$pop_inhibit_job_recovery;
      IFEND;
      IF NOT internal_status.normal THEN
        osp$disestablish_cond_handler;
        status := internal_status;
      IFEND;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, external_interface, status);
    IFEND;
  PROCEND nap$gt_accept_connection;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_await_activity_complete', EJECT ??
*copy nah$gt_await_activity_complete

  PROCEDURE [XDCL, #GATE] nap$gt_await_activity_complete
    (    wait_list: nat$gt_wait_list;
     VAR ready_index: integer;
     VAR status: ost$status);

?? NEWTITLE := '[INLINE] get_sender_active', EJECT ??

    PROCEDURE [INLINE] get_sender_active
      (    connection_id: nat$gt_connection_id;
           processing_task: ost$global_task_id;
       VAR sender_active: boolean);

      VAR
        job_connection: ^nat$gt_job_connection,
        cl_connection: ^nlt$cl_connection,
        connection: ^nat$gt_connection,
        connection_exists: boolean;

      sender_active := FALSE;
      nap$gt_get_exclusive_to_clist;
      job_connection := nav$gt_job_connection_list.first_connection;
      WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
        job_connection := job_connection^.next_connection;
      WHILEND;
      IF ((job_connection <> NIL) AND job_connection^.active) THEN
        nlp$cl_get_exclusive_via_cid (job_connection^.active_connection_id, connection_exists, cl_connection);
        IF connection_exists THEN
          sender_active := (cl_connection^.message_sender.active AND
                (processing_task = cl_connection^.message_sender.task));
          nlp$cl_release_exclusive_access (cl_connection);
        IFEND;
      IFEND;
      nap$gt_releas_exclusiv_to_clist;
    PROCEND get_sender_active;
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] get_receiver_active', EJECT ??

    PROCEDURE [INLINE] get_receiver_active
      (    connection_id: nat$gt_connection_id;
           processing_task: ost$global_task_id;
       VAR receiver_active: boolean);

      VAR
        job_connection: ^nat$gt_job_connection,
        cl_connection: ^nlt$cl_connection,
        connection: ^nat$gt_connection,
        connection_exists: boolean;

      receiver_active := FALSE;
      nap$gt_get_exclusive_to_clist;
      job_connection := nav$gt_job_connection_list.first_connection;
      WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
        job_connection := job_connection^.next_connection;
      WHILEND;
      IF ((job_connection <> NIL) AND job_connection^.active) THEN
        nlp$cl_get_exclusive_via_cid (job_connection^.active_connection_id, connection_exists, cl_connection);
        IF connection_exists THEN
          receiver_active := (cl_connection^.message_receiver.active AND
                (processing_task = cl_connection^.message_receiver.task));
          nlp$cl_release_exclusive_access (cl_connection);
        IFEND;
      IFEND;
      nap$gt_releas_exclusiv_to_clist;
    PROCEND get_receiver_active;
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] get_sap_receiver_active', EJECT ??

    PROCEDURE [INLINE] get_sap_receiver_active
      (    sap_id: nat$gt_sap_identifier;
           processing_task: ost$global_task_id;
       VAR sap_receiver_active: boolean);

      VAR
        job_sap: ^nat$gt_job_sap,
        sap: ^nat$gt_sap;

      sap_receiver_active := FALSE;
      nap$gt_get_exclusive_to_slist;
      job_sap := nav$gt_job_sap_list.first_sap;
      WHILE (job_sap <> NIL) AND (job_sap^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
        job_sap := job_sap^.next_sap;
      WHILEND;
      IF job_sap <> NIL THEN
        osp$begin_subsystem_activity;
        osp$set_job_signature_lock (nav$gt_sap_list.lock);
        sap := nav$gt_sap_list.first_sap;
        WHILE (sap <> NIL) AND (sap^.sap_id.osi_sap_identifier <> job_sap^.selector.osi_sap_identifier) DO
          sap := sap^.next_sap;
        WHILEND;
        IF sap <> NIL THEN
          sap_receiver_active := (sap^.connect_request_receiver.active AND
                (processing_task = sap^.connect_request_receiver.task));
        IFEND;
        osp$clear_job_signature_lock (nav$gt_sap_list.lock);
        osp$end_subsystem_activity;
      IFEND;
      nap$gt_releas_exclusiv_to_slist;
    PROCEND get_sap_receiver_active;
?? OLDTITLE, EJECT ??

    CONST
      local_clock = 0;

    VAR
      start_time,
      wait_time,
      current_time,
      elapsed_time: ost$free_running_clock,
      activity: integer,
      await_complete: boolean,
      time_specified: boolean,
      null_list: boolean,
      request_active: boolean,
      processing_task: ost$global_task_id;

    osp$push_inhibit_job_recovery;
    status.normal := TRUE;
    ready_index := 0;
    elapsed_time := 0;
    wait_time := UPPERVALUE (ost$free_running_clock);
    null_list := TRUE;
    time_specified := FALSE;
    pmp$get_executing_task_gtid (processing_task);
    REPEAT
      await_complete := FALSE;
      activity := 1;
      WHILE NOT await_complete AND (activity <= UPPERBOUND (wait_list)) DO
        CASE wait_list [activity].activity OF
        = nac$gt_null_activity =
          ;
        = nac$gt_await_time =
          time_specified := TRUE;
          null_list := FALSE;
          IF (elapsed_time >= (wait_list [activity].milliseconds * 1000)) THEN
            await_complete := TRUE;
          ELSEIF ((wait_list [activity].milliseconds * 1000) < wait_time) THEN
            wait_time := wait_list [activity].milliseconds * 1000;
          IFEND;
        = nac$gt_await_send_data =
          null_list := FALSE;
          get_sender_active (wait_list [activity].send_connection_id, processing_task, request_active);
          await_complete := NOT request_active;
        = nac$gt_await_receive_event =
          null_list := FALSE;
          get_receiver_active (wait_list [activity].send_connection_id, processing_task, request_active);
          await_complete := NOT request_active;
        = nac$gt_await_connect_request =
          null_list := FALSE;
          get_sap_receiver_active (wait_list [activity].sap_id, processing_task, request_active);
          await_complete := NOT request_active;
        ELSE
          await_complete := TRUE;
          osp$set_status_abnormal (nac$status_id, nae$incorrect_activity, external_interface, status);
        CASEND;
        IF NOT await_complete THEN
          activity := activity + 1;
        IFEND;
      WHILEND;

      IF await_complete THEN
        ready_index := activity;
      ELSEIF null_list THEN
        ready_index := 1;
        await_complete := TRUE;
      ELSE
        IF time_specified THEN
          IF ((wait_time - elapsed_time) > 0) THEN
            start_time := #FREE_RUNNING_CLOCK (local_clock);
            pmp$wait ((wait_time - elapsed_time) DIV 1000, (wait_time - elapsed_time) DIV 1000);
            current_time := #FREE_RUNNING_CLOCK (local_clock);
            IF current_time > start_time THEN
              elapsed_time := elapsed_time + (current_time - start_time);
            IFEND;
          IFEND;
        ELSE
          pmp$wait (100000000(16), 100000000(16));
        IFEND;
      IFEND;
    UNTIL await_complete;
    osp$pop_inhibit_job_recovery;
  PROCEND nap$gt_await_activity_complete;
?? OLDTITLE ??
?? NEWTITLE := 'reject_connection', EJECT ??

  PROCEDURE reject_connection
    (    cl_connection_id: nlt$cl_connection_id;
     VAR reject_message {INPUT, OUTPUT} : nlt$bm_message_id);

    VAR
      connection: ^nat$gt_connection,
      cl_connection: ^nlt$cl_connection,
      connection_exists: boolean,
      ignore_status: ost$status,
      layer_active: boolean;

    nlp$cl_get_exclusive_via_cid (cl_connection_id, connection_exists, cl_connection);
    IF connection_exists THEN
      nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active, connection);
      IF layer_active THEN
        nlp$ta_disconnect_connection (cl_connection, reject_message, ignore_status);
        connection^.state := nac$gt_closed;
        nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
      IFEND;
      nlp$cl_release_exclusive_access (cl_connection);
    IFEND;
  PROCEND reject_connection;
?? OLDTITLE ??
?? NEWTITLE := 'close_sap' ??
?? NEWTITLE := 'close_connection', EJECT ??

  PROCEDURE close_sap
    (    sap: ^nat$gt_sap;
         sap_id: nat$gt_sap_identifier;
         server_sap: boolean);


    PROCEDURE close_connection
      (    connection_id: nat$gt_connection_id);

      VAR
        cl_connection: ^nlt$cl_connection,
        cl_connection_id: nlt$cl_connection_id,
        connection: ^nat$gt_connection,
        connection_to_delete: ^^nat$gt_job_connection,
        connection_exists: boolean,
        empty_message: nlt$bm_message_id,
        ignore_status: ost$status,
        layer_active: boolean;

      nap$gt_get_exclusive_to_clist;
      connection_to_delete := ^nav$gt_job_connection_list.first_connection;
      WHILE (connection_to_delete^ <> NIL) AND (connection_to_delete^^.connection_id <> connection_id) DO
        connection_to_delete := ^connection_to_delete^^.next_connection;
      WHILEND;
      IF (connection_to_delete^ <> NIL) AND connection_to_delete^^.active THEN
        cl_connection_id := connection_to_delete^^.active_connection_id;
        nap$gt_delete_job_connection (connection_id);
        nap$gt_releas_exclusiv_to_clist;
        nlp$cl_get_exclusive_via_cid (cl_connection_id, connection_exists, cl_connection);
        IF connection_exists THEN
          IF cl_connection^.message_sender.active THEN
            nlp$cl_deactivate_sender (cl_connection);
          IFEND;
          IF cl_connection^.message_receiver.active THEN
            nlp$cl_deactivate_receiver (cl_connection);
          IFEND;
          nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active,
                connection);
          IF layer_active THEN
            delete_queued_events (connection);
            nlp$bm_create_message (nav$gt_null_message, empty_message, ignore_status);
            nlp$ta_disconnect_connection (cl_connection, empty_message, ignore_status);
            connection^.state := nac$gt_closed;
            nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
          IFEND;
          nlp$cl_release_exclusive_access (cl_connection);
        IFEND;
      ELSEIF connection_to_delete^ <> NIL THEN
        nap$gt_delete_job_connection (connection_id);
        nap$gt_releas_exclusiv_to_clist;
      ELSE
        nap$gt_releas_exclusiv_to_clist;
      IFEND;
    PROCEND close_connection;
?? OLDTITLE, EJECT ??

    VAR
      connection: ^nat$gt_sap_connection,
      connect_request: ^nat$gt_connect_request,
      ignore_status: ost$status,
      link: ^^nat$gt_sap_connection;

    link := ^sap^.first_connection;
    WHILE link^ <> NIL DO
      IF sap_id.osi_sap_identifier = link^^.sap_id.osi_sap_identifier THEN
        connection := link^;
        link^ := connection^.next_connection;
        close_connection (connection^.connection_id);
        FREE connection IN nav$network_paged_heap^;
      ELSE
        link := ^link^^.next_connection;
      IFEND;
    WHILEND;

    IF server_sap THEN
      WHILE sap^.connect_request_queue.beginning <> NIL DO
        connect_request := sap^.connect_request_queue.beginning;
        sap^.connect_request_queue.beginning := connect_request^.next_connect_request;
        reject_connection (connect_request^.connection_id, connect_request^.data);
        FREE connect_request IN nav$network_paged_heap^;
      WHILEND;
    IFEND;
    nlp$ta_close_sap (sap^.sap_id.osi_sap_identifier, ignore_status);
  PROCEND close_sap;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_close_sap', EJECT ??
*copy nah$gt_close_sap

  PROCEDURE [XDCL, #GATE] nap$gt_close_sap
    (    sap_id: nat$gt_sap_identifier;
     VAR status: ost$status);

    VAR
      sap_to_delete: ^nat$gt_job_sap,
      active_sap: ^^nat$gt_sap,
      sap_to_close: ^nat$gt_sap,
      sap_found: boolean,
      selector: nat$gt_sap_identifier,
      server_sap: boolean,
      internal_status: ost$status;

    status.normal := TRUE;
    osp$push_inhibit_job_recovery;
    nap$gt_get_exclusive_to_slist;
    get_sap_to_delete (sap_id, sap_to_delete, internal_status);
    IF internal_status.normal THEN
      server_sap := sap_to_delete^.shared_sap_server;
      selector := sap_to_delete^.selector;
      nap$gt_delete_job_sap (sap_id);
      nap$gt_releas_exclusiv_to_slist;
      FREE sap_to_delete IN nav$network_paged_heap^;
      osp$begin_subsystem_activity;
      osp$set_job_signature_lock (nav$gt_sap_list.lock);
      unassign_sap_identifier (sap_id.osi_sap_identifier);
      find_active_sap (selector, active_sap, sap_found);
      IF sap_found THEN
        IF (server_sap) AND (active_sap^^.connect_request_receiver.active) THEN
          active_sap^^.connect_request_receiver.active := FALSE;
        IFEND;
        IF (NOT active_sap^^.opened_via_share) OR (active_sap^^.shared_sap_count <= 1) THEN
          sap_to_close := active_sap^;
          active_sap^ := active_sap^^.next_sap;
          close_sap (sap_to_close, sap_id, server_sap);
          FREE sap_to_close IN nav$network_paged_heap^;
        ELSE
          active_sap^^.shared_sap_count := active_sap^^.shared_sap_count - 1;
          close_sap (active_sap^, sap_id, server_sap);
          IF server_sap THEN
            active_sap^^.shared_sap_server_active := FALSE;
          IFEND;
        IFEND;
      IFEND;
      osp$clear_job_signature_lock (nav$gt_sap_list.lock);
      osp$end_subsystem_activity;
    ELSE
      nap$gt_releas_exclusiv_to_slist;
    IFEND;
    osp$pop_inhibit_job_recovery;
    IF NOT internal_status.normal THEN
      status := internal_status;
    IFEND;
  PROCEND nap$gt_close_sap;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_process_job_termination', EJECT ??

{ The purpose of this procedure is to release all sap and connections in the current job.

  PROCEDURE [XDCL] nap$gt_process_job_termination;

    VAR
      active_sap: ^^nat$gt_sap,
      sap_to_close: ^nat$gt_sap,
      sap_to_delete: ^nat$gt_job_sap,
      sap_found: boolean,
      sap_id: nat$gt_sap_identifier,
      selector: nat$gt_sap_identifier,
      server_sap: boolean;

    osp$push_inhibit_job_recovery;
    nap$gt_get_exclusive_to_slist;
    WHILE nav$gt_job_sap_list.first_sap <> NIL DO
      sap_to_delete := nav$gt_job_sap_list.first_sap;
      server_sap := sap_to_delete^.shared_sap_server;
      selector := sap_to_delete^.selector;
      sap_id := sap_to_delete^.sap_id;
      nap$gt_delete_job_sap (sap_to_delete^.sap_id);
      osp$begin_subsystem_activity;
      osp$set_job_signature_lock (nav$gt_sap_list.lock);
      unassign_sap_identifier (sap_id.osi_sap_identifier);
      find_active_sap (selector, active_sap, sap_found);
      IF sap_found THEN
        IF (server_sap) AND (active_sap^^.connect_request_receiver.active) THEN
          active_sap^^.connect_request_receiver.active := FALSE;
        IFEND;
        sap_to_close := active_sap^;
        IF (NOT sap_to_close^.opened_via_share) OR (sap_to_close^.shared_sap_count <= 1) THEN
          active_sap^ := sap_to_close^.next_sap;
          close_sap (sap_to_close, sap_id, server_sap);
          FREE sap_to_close IN nav$network_paged_heap^;
        ELSE
          sap_to_close^.shared_sap_count := sap_to_close^.shared_sap_count - 1;
          close_sap (active_sap^, sap_id, server_sap);
          IF server_sap THEN
            active_sap^^.shared_sap_server_active := FALSE;
          IFEND;
        IFEND;
      IFEND;
      osp$clear_job_signature_lock (nav$gt_sap_list.lock);
      osp$end_subsystem_activity;
      FREE sap_to_delete IN nav$network_paged_heap^;
    WHILEND;
    nap$gt_releas_exclusiv_to_slist;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$gt_process_job_termination;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_disconnect', EJECT ??
*copy nah$gt_disconnect

  PROCEDURE [XDCL, #GATE] nap$gt_disconnect
    (    connection_id: nat$gt_connection_id,
         data: nat$data_fragments;
     VAR status: ost$status);

    VAR
      cl_connection: ^nlt$cl_connection;

?? NEWTITLE := 'terminate_disconnect', EJECT ??

    PROCEDURE terminate_disconnect
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        nlp$cl_clear_exclusive_access (cl_connection);
        osp$pop_inhibit_job_recovery;
        osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
        EXIT nap$gt_disconnect;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_disconnect;
?? OLDTITLE, EJECT ??

    VAR
      connection: ^nat$gt_connection,
      connection_to_delete: ^nat$gt_job_connection,
      data_length: nat$data_length,
      message_id: nlt$bm_message_id,
      internal_status: ost$status;

    status.normal := TRUE;

    IF UPPERBOUND (data) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_length (data, data_length);
    IF data_length <= nac$gt_maximum_disconnect_data THEN
      osp$push_inhibit_job_recovery;
      nap$gt_get_exclusive_to_clist;
      get_connection_to_delete (connection_id, connection_to_delete, cl_connection, connection,
            internal_status);
      IF internal_status.normal THEN
        delete_connection_from_sap (connection_id, connection_to_delete^.sap_id);
        nap$gt_delete_job_connection (connection_id);
        nap$gt_releas_exclusiv_to_clist;
        IF cl_connection^.message_sender.active THEN
          nlp$cl_deactivate_sender (cl_connection);
        IFEND;
        IF cl_connection^.message_receiver.active THEN
          nlp$cl_deactivate_receiver (cl_connection);
        IFEND;
        delete_queued_events (connection);
        nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
        osp$establish_condition_handler (^terminate_disconnect, FALSE);
        nlp$bm_create_message (data, message_id, internal_status);
        osp$disestablish_cond_handler;
        nlp$ta_disconnect_connection (cl_connection, message_id, internal_status);
        nlp$cl_release_exclusive_access (cl_connection);
      ELSE
        nap$gt_releas_exclusiv_to_clist;
      IFEND;
      osp$pop_inhibit_job_recovery;
      IF NOT internal_status.normal THEN
        osp$disestablish_cond_handler;
        status := internal_status;
      IFEND;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, external_interface, status);
    IFEND;
  PROCEND nap$gt_disconnect;
?? TITLE := ' [XDCL] nap$gt_initialize', EJECT ??

  PROCEDURE [XDCL] nap$gt_initialize;

*copyc nah$gt_initialize

    VAR
      connection_processor: nlt$cl_event_processor,
      sap_processor: nlt$cl_event_processor;

    nlp$cl_initialize_template (nlc$osi_generic_xport_interface,
          nlc$osi_generic_xport_interface, #SIZE (nat$gt_connection), 0,
          sap_processor, nac$gt_evaluate_sap_timers, connection_processor,
          nac$gt_evaluate_connect_timers);
    nlp$ta_initialize (nlc$osi_generic_xport_interface, nac$osi_gt_process_sap_event,
          nac$osi_gt_process_conn_event);
  PROCEND nap$gt_initialize;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_open_sap', EJECT ??
*copy nah$gt_open_sap

  PROCEDURE [XDCL, #GATE] nap$gt_open_sap
    (    maximum_active_connections: nat$maximum_active_connections;
         sap_priority: nat$network_message_priority;
         reserved_sap: boolean;
     VAR sap_id {INPUT, OUTPUT} : nat$gt_sap_identifier;
     VAR address: nat$internet_address;
     VAR status: ost$status);

    VAR
      sap_processor: nlt$cl_event_processor,
      connection_processor: nlt$cl_event_processor,
      ignore_status: ost$status,
      internal_status: ost$status,
      job_sap: ^nat$gt_job_sap,
      new_sap: ^nat$gt_sap;

    IF NOT nav$namve_active THEN
      osp$set_status_condition ( nae$network_inactive,  status);
      RETURN;
    IFEND;

    status.normal := TRUE;
    IF (sap_priority < 0) OR (sap_priority > UPPERVALUE (sap_priority)) THEN
      osp$set_status_condition (nae$invalid_sap_priority, status);
      RETURN;
    IFEND;
    IF ((maximum_active_connections > 0) AND (maximum_active_connections <=
          UPPERVALUE (nat$maximum_active_connections))) THEN
      osp$push_inhibit_job_recovery;
      ALLOCATE job_sap IN nav$network_paged_heap^;
      internal_status.normal := TRUE;
      IF job_sap <> NIL THEN
        ALLOCATE new_sap IN nav$network_paged_heap^;
        IF new_sap <> NIL THEN
          new_sap^ := nav$gt_null_sap;
          new_sap^.sap_id.xns_sap_identifier := 0;
          new_sap^.opened_via_share := FALSE;
          new_sap^.shared_sap_server_active := FALSE;
          assign_sap_identifier (reserved_sap, sap_id.osi_sap_identifier, { shared_sap = } FALSE,
                new_sap^.sap_id.osi_sap_identifier, internal_status);
          IF internal_status.normal THEN
            nlp$cl_initialize_template (nlc$osi_generic_xport_interface,
                  nlc$osi_generic_xport_interface, #SIZE (nat$gt_connection), 0, sap_processor,
                  nac$gt_evaluate_sap_timers, connection_processor, nac$gt_evaluate_connect_timers);
            nlp$ta_open_sap (nlc$osi_generic_xport_interface, nac$osi_gt_process_sap_event,
                  nac$osi_gt_process_conn_event, internal_status);
            IF internal_status.normal THEN
              job_sap^.sap_id := new_sap^.sap_id;
              job_sap^.selector := new_sap^.sap_id;
              job_sap^.priority := sap_priority;
              job_sap^.shared_sap_server := TRUE;
              sap_id := new_sap^.sap_id;
              nap$gt_add_job_sap (job_sap);
              osp$begin_subsystem_activity;
              osp$set_job_signature_lock (nav$gt_sap_list.lock);
              new_sap^.next_sap := nav$gt_sap_list.first_sap;
              nav$gt_sap_list.first_sap := new_sap;
              osp$clear_job_signature_lock (nav$gt_sap_list.lock);
              osp$end_subsystem_activity;
            ELSE
              unassign_sap_identifier (new_sap^.sap_id.osi_sap_identifier);
              FREE job_sap IN nav$network_paged_heap^;
              FREE new_sap IN nav$network_paged_heap^;
            IFEND;
          ELSE { Unable to assign sap identifier.
            FREE job_sap IN nav$network_paged_heap^;
            FREE new_sap IN nav$network_paged_heap^;
          IFEND;
        ELSE { new_sap ALLOCATION failed.
          FREE job_sap IN nav$network_paged_heap^;
          osp$set_status_abnormal (nac$status_id, nae$insufficient_resources, external_interface,
                internal_status);
        IFEND;
      ELSE { job_sap ALLOCATION failed.
        osp$set_status_abnormal (nac$status_id, nae$insufficient_resources, external_interface,
              internal_status);
      IFEND;
      osp$pop_inhibit_job_recovery;
      IF NOT internal_status.normal THEN
        status := internal_status;
      IFEND;
    ELSEIF maximum_active_connections = 0 THEN
      osp$set_status_condition ( nae$max_active_connections_0,  status);
    ELSE
      osp$set_status_condition ( nae$max_active_conn_exceeded,  status);
    IFEND;
  PROCEND nap$gt_open_sap;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_open_shared_sap', EJECT ??
*copy nah$gt_open_shared_sap

  PROCEDURE [XDCL, #GATE] nap$gt_open_shared_sap
    (    maximum_active_connections: nat$maximum_active_connections;
         sap_priority: nat$network_message_priority;
         selector: nat$gt_sap_identifier,
         server_job: boolean;
     VAR sap_id : nat$gt_sap_identifier;
     VAR status: ost$status);

    VAR
      sap_processor: nlt$cl_event_processor,
      connection_processor: nlt$cl_event_processor,
      ignore_status: ost$status,
      internal_status: ost$status,
      job_sap: ^nat$gt_job_sap,
      new_sap_created: boolean,
      sap: ^nat$gt_sap;

    IF NOT nav$namve_active THEN
      osp$set_status_condition ( nae$network_inactive,  status);
      RETURN;
    IFEND;

    status.normal := TRUE;
    IF ((maximum_active_connections > 0) AND (maximum_active_connections <=
          UPPERVALUE (nat$maximum_active_connections))) THEN
      internal_status.normal := TRUE;
      osp$push_inhibit_job_recovery;
      ALLOCATE job_sap IN nav$network_paged_heap^;
      IF job_sap <> NIL THEN
        new_sap_created := FALSE;

        sap := nav$gt_sap_list.first_sap;
        WHILE (sap <> NIL) AND
              (sap^.sap_id.osi_sap_identifier <> selector.osi_sap_identifier) DO
          sap := sap^.next_sap;
        WHILEND;
        IF sap = NIL THEN
          ALLOCATE sap IN nav$network_paged_heap^;
          IF sap <> NIL THEN
            new_sap_created := TRUE;
            sap^ := nav$gt_null_sap;
            sap^.opened_via_share := TRUE;
            sap^.shared_sap_server_active := FALSE;
            sap^.sap_id := selector;
          ELSE { sap = NIL
            osp$set_status_abnormal (nac$status_id, nae$insufficient_resources, external_interface,
                  internal_status);
          IFEND;
        ELSEIF NOT sap^.opened_via_share THEN
          osp$set_status_abnormal (nac$status_id, nae$sap_cannot_be_shared, external_interface,
                internal_status);
          osp$append_status_integer (osc$status_parameter_delimiter, selector.osi_sap_identifier, 10,
                TRUE, internal_status);
        ELSEIF (server_job) AND (sap^.shared_sap_server_active) THEN
          osp$set_status_abnormal (nac$status_id, nae$shared_server_sap_open, external_interface,
                internal_status);
          osp$append_status_integer (osc$status_parameter_delimiter, selector.osi_sap_identifier, 10,
                TRUE, internal_status);
        IFEND;

        IF internal_status.normal THEN
          assign_sap_identifier ({ reserved_sap = } TRUE, selector.osi_sap_identifier,
                { shared_sap = } TRUE, job_sap^.sap_id.osi_sap_identifier,internal_status);
          IF internal_status.normal THEN
            nlp$cl_initialize_template (nlc$osi_generic_xport_interface,
                  nlc$osi_generic_xport_interface, #SIZE (nat$gt_connection), 0, sap_processor,
                  nac$gt_evaluate_sap_timers, connection_processor, nac$gt_evaluate_connect_timers);
            nlp$ta_open_sap (nlc$osi_generic_xport_interface, nac$osi_gt_process_sap_event,
                  nac$osi_gt_process_conn_event, internal_status);
            IF internal_status.normal THEN

{ Increment shared sap count.

              sap^.shared_sap_count := sap^.shared_sap_count + 1;
              IF (NOT sap^.shared_sap_server_active) AND (server_job) THEN
                sap^.shared_sap_server_active := TRUE;
              IFEND;
              job_sap^.sap_id.xns_sap_identifier := 0;
              job_sap^.selector := selector;
              job_sap^.next_sap := NIL;
              job_sap^.priority := sap_priority;
              job_sap^.shared_sap_server := server_job;
              sap_id := job_sap^.sap_id;
              nap$gt_add_job_sap (job_sap);
              IF new_sap_created THEN
                osp$begin_subsystem_activity;
                osp$set_job_signature_lock (nav$gt_sap_list.lock);
                sap^.next_sap := nav$gt_sap_list.first_sap;
                nav$gt_sap_list.first_sap := sap;
                osp$clear_job_signature_lock (nav$gt_sap_list.lock);
                osp$end_subsystem_activity;
              IFEND;
            ELSE
              unassign_sap_identifier (sap^.sap_id.osi_sap_identifier);
              FREE job_sap IN nav$network_paged_heap^;
              IF new_sap_created THEN
                FREE sap IN nav$network_paged_heap^;
              IFEND;
            IFEND;
          ELSE { Unable to assign sap identifier.
            FREE job_sap IN nav$network_paged_heap^;
            IF new_sap_created THEN
              FREE sap IN nav$network_paged_heap^;
            IFEND;
          IFEND;
        ELSE
          FREE job_sap IN nav$network_paged_heap^;
        IFEND;
      ELSE { job_sap ALLOCATION failed.
        osp$set_status_abnormal (nac$status_id, nae$insufficient_resources, external_interface,
              internal_status);
      IFEND;
      osp$pop_inhibit_job_recovery;
      IF NOT internal_status.normal THEN
        status := internal_status;
      IFEND;
    ELSEIF maximum_active_connections = 0 THEN
      osp$set_status_condition ( nae$max_active_connections_0,  status);
    ELSE
      osp$set_status_condition ( nae$max_active_conn_exceeded,  status);
    IFEND;
  PROCEND nap$gt_open_shared_sap;
?? OLDTITLE ??
?? NEWTITLE := 'deliver_connection_events', EJECT ??

  PROCEDURE deliver_connection_events
    (    connection: ^nat$gt_connection;
         cl_connection: ^nlt$cl_connection;
     VAR delivery_complete: boolean);

{
{   ENTRY REQUIREMENT: the process of delivering connection events is dependent on the caller having a
{                      condition handler established to field conditions arising from an invalid user
{                      data area.  Further, it is expected that the condition handler causes any updating
{                      of interface flow control to be circumvented if such a condition occurs.
{

    VAR
      executing_task: ost$global_task_id,
      event_queue: ^^nat$gt_event_element,
      event_to_free: ^nat$gt_event_element,
      end_of_message: boolean,
      delivered_message_buffers: nat$data_length,
      ignore_rbc: nat$data_length;

    delivery_complete := FALSE;
    IF connection^.event_queue.beginning <> NIL THEN
      pmp$get_executing_task_gtid (executing_task);
      IF executing_task = cl_connection^.message_receiver.task THEN
        event_queue := ^connection^.event_queue.beginning;
        CASE event_queue^^.event.kind OF
        = nlc$ta_data_event =
          connection^.receiver_request.application_event^.kind := nac$gt_data_event;
          IF event_queue^^.data_length <= connection^.receiver_request.remaining_buffer_capacity THEN
            connection^.receiver_request.delivered_data_length :=
                  connection^.receiver_request.delivered_data_length + event_queue^^.data_length;
            connection^.receiver_request.application_event^.data.data_length :=
                  connection^.receiver_request.delivered_data_length;
            end_of_message := event_queue^^.event.osi_data.end_of_message;
            connection^.receiver_request.application_event^.data.end_of_message := end_of_message;
            CASE connection^.receiver_request.application_buffer.description_kind OF
            = nac$gt_fixed =
              nlp$al_deliver_data (event_queue^^.event.osi_data.data,
                    connection^.receiver_request.application_buffer.fixed_description,
                    connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
            = nac$gt_allocated =
              nlp$al_deliver_data (event_queue^^.event.osi_data.data,
                    connection^.receiver_request.application_buffer.allocated_description^,
                    connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
              IF end_of_message OR (connection^.receiver_request.remaining_buffer_capacity = 0) OR
                    (event_queue^^.next_event <> NIL) THEN
                FREE connection^.receiver_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              IFEND;
            CASEND;
            connection^.undelivered_message_buffers := connection^.undelivered_message_buffers -
                  delivered_message_buffers;
            event_to_free := event_queue^;
            event_queue^ := event_to_free^.next_event;
            FREE event_to_free IN nav$network_paged_heap^;
            delivery_complete := end_of_message OR (connection^.receiver_request.remaining_buffer_capacity =
                  0) OR (event_queue^ <> NIL);
            connection^.receiver_request.data_delivery_in_progress := NOT delivery_complete;
            IF event_queue^ = NIL THEN
              connection^.event_queue.ending := NIL;
              nlp$cancel_timer (connection^.timer);
            ELSE
              nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
            IFEND;
          ELSE
            connection^.receiver_request.delivered_data_length :=
                  connection^.receiver_request.delivered_data_length +
                  connection^.receiver_request.remaining_buffer_capacity;
            connection^.receiver_request.application_event^.data.data_length :=
                  connection^.receiver_request.delivered_data_length;
            connection^.receiver_request.application_event^.data.end_of_message := FALSE;
            CASE connection^.receiver_request.application_buffer.description_kind OF
            = nac$gt_fixed =
              nlp$al_deliver_data (event_queue^^.event.osi_data.data,
                    connection^.receiver_request.application_buffer.fixed_description, ignore_rbc,
                    delivered_message_buffers);
            = nac$gt_allocated =
              nlp$al_deliver_data (event_queue^^.event.osi_data.data,
                    connection^.receiver_request.application_buffer.allocated_description^, ignore_rbc,
                    delivered_message_buffers);
              FREE connection^.receiver_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            CASEND;
            event_queue^^.data_length := event_queue^^.data_length -
                  connection^.receiver_request.remaining_buffer_capacity;
            connection^.undelivered_message_buffers := connection^.undelivered_message_buffers -
                  delivered_message_buffers;
            delivery_complete := TRUE;
            connection^.receiver_request.data_delivery_in_progress := FALSE;
            nlp$select_timer ((nac$gt_event_timer_duration DIV 2), 0, connection^.timer);
          IFEND;
?? EJECT ??

        = nlc$ta_disconnect_event =
          IF NOT connection^.receiver_request.data_delivery_in_progress THEN
            connection^.receiver_request.application_event^.kind := nac$gt_disconnect_event;
            IF event_queue^^.event.osi_disconnect.proprietary_reason = nlc$ta_user_disconnect_request THEN
              connection^.receiver_request.application_event^.disconnect.reason :=
                    event_queue^^.event.osi_disconnect.osi_8073_reason;
              connection^.receiver_request.application_event^.disconnect.data_length :=
                    event_queue^^.data_length;
              CASE connection^.receiver_request.application_buffer.description_kind OF
              = nac$gt_fixed =
                nlp$al_deliver_data (event_queue^^.event.osi_disconnect.data,
                      connection^.receiver_request.application_buffer.fixed_description,
                      connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
              = nac$gt_allocated =
                nlp$al_deliver_data (event_queue^^.event.osi_disconnect.data,
                      connection^.receiver_request.application_buffer.allocated_description^,
                      connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
                FREE connection^.receiver_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              CASEND;
            ELSE
              connection^.receiver_request.application_event^.disconnect.reason := nac$gt_layer_disconnect;
              CASE connection^.receiver_request.application_buffer.description_kind OF
              = nac$gt_fixed =
                ;
              = nac$gt_allocated =
                FREE connection^.receiver_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              CASEND;
            IFEND;
            event_to_free := event_queue^;
            event_queue^ := event_queue^^.next_event;
            FREE event_to_free IN nav$network_paged_heap^;
            IF event_queue^ = NIL THEN
              connection^.event_queue.ending := NIL;
            IFEND;
            delivery_complete := TRUE;
          ELSE
            connection^.receiver_request.data_delivery_in_progress := FALSE;
            CASE connection^.receiver_request.application_buffer.description_kind OF
            = nac$gt_fixed =
              ;
            = nac$gt_allocated =
              FREE connection^.receiver_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            CASEND;
            delivery_complete := TRUE;
            nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
          IFEND;
?? EJECT ??

        = nlc$ta_connect_confirm_event =
          connection^.receiver_request.application_event^.kind := nac$gt_accept_event;
          connection^.receiver_request.application_event^.accept.data_length := event_queue^^.data_length;
          connection^.receiver_request.application_event^.accept.checksum :=
                event_queue^^.event.osi_connect_confirm.checksum;
          connection^.receiver_request.application_event^.accept.expedited_data :=
                event_queue^^.event.osi_connect_confirm.expedited_data;
          CASE connection^.receiver_request.application_buffer.description_kind OF
          = nac$gt_fixed =
            nlp$al_deliver_data (event_queue^^.event.osi_connect_confirm.data,
                  connection^.receiver_request.application_buffer.fixed_description,
                  connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
          = nac$gt_allocated =
            nlp$al_deliver_data (event_queue^^.event.osi_connect_confirm.data,
                  connection^.receiver_request.application_buffer.allocated_description^,
                  connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
            FREE connection^.receiver_request.application_buffer.allocated_description IN
                  nav$network_paged_heap^;
          CASEND;
          event_to_free := event_queue^;
          event_queue^ := event_to_free^.next_event;
          FREE event_to_free IN nav$network_paged_heap^;
          IF event_queue^ = NIL THEN
            connection^.event_queue.ending := NIL;
          IFEND;
          delivery_complete := TRUE;
          nlp$cancel_timer (connection^.timer);
?? EJECT ??

        = nlc$ta_expedited_data_event =
          IF NOT connection^.receiver_request.data_delivery_in_progress THEN
            connection^.receiver_request.application_event^.kind := nac$gt_expedited_data_event;
            connection^.receiver_request.application_event^.expedited_data.data_length :=
                  event_queue^^.data_length;
            CASE connection^.receiver_request.application_buffer.description_kind OF
            = nac$gt_fixed =
              nlp$al_deliver_data (event_queue^^.event.osi_expedited_data.data,
                    connection^.receiver_request.application_buffer.fixed_description,
                    connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
            = nac$gt_allocated =
              nlp$al_deliver_data (event_queue^^.event.osi_expedited_data.data,
                    connection^.receiver_request.application_buffer.allocated_description^,
                    connection^.receiver_request.remaining_buffer_capacity, delivered_message_buffers);
              FREE connection^.receiver_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            CASEND;
            event_to_free := event_queue^;
            event_queue^ := event_to_free^.next_event;
            FREE event_to_free IN nav$network_paged_heap^;
            IF event_queue^ = NIL THEN
              connection^.event_queue.ending := NIL;
              nlp$cancel_timer (connection^.timer);
            ELSE
              nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
            IFEND;
            delivery_complete := TRUE;
          ELSE
            connection^.receiver_request.data_delivery_in_progress := FALSE;
            CASE connection^.receiver_request.application_buffer.description_kind OF
            = nac$gt_fixed =
              ;
            = nac$gt_allocated =
              FREE connection^.receiver_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            CASEND;
            delivery_complete := TRUE;
            nlp$select_timer ((nac$gt_event_timer_duration DIV 2), 0, connection^.timer);
          IFEND;
        CASEND;
      ELSE
        activate_receiver_task (cl_connection);
      IFEND;
    IFEND;
  PROCEND deliver_connection_events;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_receive_connection_event', EJECT ??
*copy nah$gt_receive_connection_event

  PROCEDURE [XDCL, #GATE] nap$gt_receive_connection_event
    (    connection_id: nat$gt_connection_id;
         data_area: nat$data_fragments;
         wait: ost$wait;
     VAR connection_event: nat$gt_event;
     VAR activity_status: ost$activity_status;
     VAR status: ost$status);

    VAR
      job_connection: ^nat$gt_job_connection,
      cl_connection: ^nlt$cl_connection,
      condition_cause: nat$gt_condition_cause,
      connection: ^nat$gt_connection;

?? NEWTITLE := 'terminate_receive', EJECT ??

    PROCEDURE terminate_receive
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        requesting_task: ost$global_task_id;

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        IF ((condition_cause = nac$gt_application_data) OR (condition_cause = nac$gt_application_event)) THEN
          IF cl_connection <> NIL THEN
            pmp$get_executing_task_gtid (requesting_task);
            IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task =
                  requesting_task) THEN
              nlp$cl_deactivate_receiver (cl_connection);
              IF ((connection^.receiver_request.application_buffer.description_kind = nac$gt_allocated) AND
                    (connection^.receiver_request.application_buffer.allocated_description <> NIL)) THEN
                FREE connection^.receiver_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              IFEND;
              connection^.receiver_request := nav$gt_null_receiver_request;
              CASE connection^.state OF
              = nac$gt_open =
                ;
              = nac$gt_accept_received =
                connection^.state := nac$gt_open;
              = nac$gt_peer_reject, nac$gt_peer_disconnect, nac$gt_connection_failed =
                connection^.state := nac$gt_closed;
                nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
                delete_connection_from_sap (connection_id, job_connection^.sap_id);
                nap$gt_delete_job_connection (connection_id);
              CASEND;
            IFEND;
            nlp$cl_release_exclusive_access (cl_connection);
          IFEND;
          nap$gt_clear_exclusive_to_clist;
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
          EXIT nap$gt_receive_connection_event;
        ELSE
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_receive;
?? OLDTITLE ??
?? NEWTITLE := 'terminate_inactive ', EJECT ??

    PROCEDURE terminate_inactive
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        osp$pop_inhibit_job_recovery;
        osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
        EXIT nap$gt_receive_connection_event;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_inactive;
?? OLDTITLE, EJECT ??

    VAR
      buffer_description: ^nlt$al_data_description,
      buffer_length: integer,
      cl_connection_id: nlt$cl_connection_id,
      connection_exists: boolean,
      data_delivery_in_progress: boolean,
      data_length: integer,
      delivery_complete: boolean,
      description_upperbound: integer,
      ignore_dmb: nat$data_length,
      ignore_rbc: nat$data_length,
      internal_status: ost$status,
      layer_active: boolean,
      message_id: nlt$bm_message_id,
      request_complete: boolean,
      requesting_task: ost$global_task_id,
      termination_state: nac$gt_peer_reject .. nac$gt_connection_failed;

    status.normal := TRUE;
    internal_status.normal := TRUE;
    activity_status.status.normal := TRUE;
    activity_status.complete := TRUE;

    IF UPPERBOUND (data_area) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_requirements (data_area, buffer_length, description_upperbound);
    IF buffer_length > nac$max_data_length THEN
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, 'nac$max_data_length', status);
      RETURN;
    IFEND;
    IF buffer_length >= nac$gt_maximum_disconnect_data THEN
      cl_connection := NIL;
      condition_cause := nac$gt_request_not_cause;
      #SPOIL (condition_cause, cl_connection);
      osp$push_inhibit_job_recovery;
      osp$establish_condition_handler (^terminate_receive, FALSE);
      request_complete := FALSE;
      WHILE internal_status.normal AND NOT request_complete DO
        nap$gt_get_exclusive_to_clist;
        job_connection := nav$gt_job_connection_list.first_connection;
        WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
          job_connection := job_connection^.next_connection;
        WHILEND;
        IF ((job_connection <> NIL) AND job_connection^.active) THEN
          nlp$cl_get_exclusive_via_cid (job_connection^.active_connection_id, connection_exists,
                cl_connection);
          IF connection_exists THEN
            nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active,
                  connection);
            IF layer_active THEN
              IF NOT cl_connection^.message_receiver.active THEN
                nlp$cl_activate_receiver (cl_connection);
                condition_cause := nac$gt_application_data;
                #SPOIL (condition_cause);
                IF description_upperbound <= nac$gt_fixed_fragments THEN
                  connection^.receiver_request.application_buffer.description_kind := nac$gt_fixed;
                  nlp$al_initialize_data_descrip (data_area, buffer_length,
                        connection^.receiver_request.application_buffer.fixed_description);
                ELSE
                  connection^.receiver_request.application_buffer.description_kind := nac$gt_allocated;
                  REPEAT
                    ALLOCATE connection^.receiver_request.application_buffer.allocated_description:
                          [1 .. description_upperbound] IN nav$network_paged_heap^;
                    IF connection^.receiver_request.application_buffer.allocated_description = NIL THEN
                      syp$cycle;
                    IFEND;
                  UNTIL connection^.receiver_request.application_buffer.allocated_description <> NIL;
                  nlp$al_initialize_data_descrip (data_area, buffer_length,
                        connection^.receiver_request.application_buffer.allocated_description^);
                IFEND;
                connection^.receiver_request.activity_status := ^activity_status;
                connection^.receiver_request.application_event := ^connection_event;
                connection^.receiver_request.delivered_data_length := 0;
                connection^.receiver_request.remaining_buffer_capacity := buffer_length;
                data_delivery_in_progress := connection^.receiver_request.data_delivery_in_progress;
                deliver_connection_events (connection, cl_connection, delivery_complete);
                condition_cause := nac$gt_request_not_cause;
                #SPOIL (condition_cause);
                nlp$ta_report_undelivered_data (cl_connection, connection^.undelivered_message_buffers);
                IF delivery_complete THEN
                  nlp$cl_deactivate_receiver (cl_connection);
                  connection^.receiver_request := nav$gt_null_receiver_request;
                  CASE connection^.state OF
                  = nac$gt_open =
                    ;
                  = nac$gt_accept_received =
                    connection^.state := nac$gt_open;
                  = nac$gt_peer_reject, nac$gt_peer_disconnect, nac$gt_connection_failed =
                    IF NOT data_delivery_in_progress THEN
                      connection^.state := nac$gt_closed;
                      nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
                      delete_connection_from_sap (connection_id, job_connection^.sap_id);
                      nap$gt_delete_job_connection (connection_id);
                    ELSE
                      nap$gt_deactivate_job_connect (connection^.state,
                            connection^.event_queue.beginning^.event,
                            connection^.event_queue.beginning^.data_length, job_connection);
                      CASE connection^.state OF
                      = nac$gt_peer_reject, nac$gt_peer_disconnect =
                        FREE connection^.event_queue.beginning IN nav$network_paged_heap^;
                      = nac$gt_connection_failed =
                        ;
                      CASEND;
                      connection^.state := nac$gt_closed;
                      nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
                    IFEND;
                  CASEND;
                  nlp$cl_release_exclusive_access (cl_connection);
                  nap$gt_releas_exclusiv_to_clist;
                  request_complete := TRUE;
                ELSE
                  condition_cause := nac$gt_request_not_cause;
                  #SPOIL (condition_cause);
                  cl_connection_id := cl_connection^.identifier;
                  nlp$cl_release_exclusive_access (cl_connection);
                  nap$gt_releas_exclusiv_to_clist;
                  activity_status.complete := FALSE;
                  IF (wait = osc$wait) THEN
                    pmp$wait (1000, 200);
                    pmp$get_executing_task_gtid (requesting_task);

                  /wait_for_request_complete/
                    REPEAT
                      nlp$cl_get_exclusive_via_cid (cl_connection_id, connection_exists, cl_connection);
                      IF connection_exists THEN
                        IF NOT cl_connection^.message_receiver.active OR
                              (cl_connection^.message_receiver.task <> requesting_task) THEN
                          request_complete := TRUE;
                          nlp$cl_release_exclusive_access (cl_connection);
                        ELSE
                          nlp$cl_release_exclusive_access (cl_connection);
                          pmp$wait (2000000, 2000000);
                        IFEND;
                      ELSE
                        request_complete := TRUE;
                        osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface,
                              internal_status);
                      IFEND;
                    UNTIL request_complete;
                  ELSE
                    request_complete := TRUE;
                  IFEND;
                IFEND;
              ELSEIF wait = osc$wait THEN
                nlp$cl_release_exclusive_access (cl_connection);
                nap$gt_releas_exclusiv_to_clist;
                pmp$wait (1000, 1000);
              ELSE
                nlp$cl_release_exclusive_access (cl_connection);
                nap$gt_releas_exclusiv_to_clist;
                osp$set_status_abnormal (nac$status_id, nae$receive_outstanding, external_interface,
                      internal_status);
              IFEND;
            ELSE
              nlp$cl_release_exclusive_access (cl_connection);
              delete_connection_from_sap (connection_id, job_connection^.sap_id);
              nap$gt_delete_job_connection (connection_id);
              nap$gt_releas_exclusiv_to_clist;
              osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface,
                    internal_status);
            IFEND;
          ELSE
            delete_connection_from_sap (connection_id, job_connection^.sap_id);
            nap$gt_delete_job_connection (connection_id);
            nap$gt_releas_exclusiv_to_clist;
            osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface,
                  internal_status);
          IFEND;
        ELSEIF job_connection <> NIL THEN
          PUSH buffer_description: [1 .. description_upperbound];
          termination_state := job_connection^.termination_state;
          condition_cause := nac$gt_application_event;
          #SPOIL (condition_cause);
          CASE termination_state OF
          = nac$gt_peer_disconnect =
            connection_event.kind := nac$gt_disconnect_event;
            connection_event.disconnect.reason := nac$gt_user_disconnect;
            nlp$bm_get_message_length (job_connection^.termination_event.osi_disconnect.data, data_length);
            connection_event.disconnect.data_length := data_length;
            nlp$bm_copy_message (job_connection^.termination_event.osi_disconnect.data, message_id);
          = nac$gt_connection_failed =
            connection_event.kind := nac$gt_disconnect_event;
            connection_event.disconnect.reason := nac$gt_layer_disconnect;
          ELSE
          CASEND;
          delete_connection_from_sap (connection_id, job_connection^.sap_id);
          nap$gt_delete_job_connection (connection_id);
          nap$gt_releas_exclusiv_to_clist;
          osp$establish_condition_handler (^terminate_inactive, FALSE);
          IF termination_state = nac$gt_peer_disconnect THEN
            condition_cause := nac$gt_application_data;
            #SPOIL (condition_cause);
            nlp$al_initialize_data_descrip (data_area, buffer_length, buffer_description^);
            nlp$al_deliver_data (message_id, buffer_description^, ignore_rbc, ignore_dmb);
            nlp$bm_release_message (message_id);
          IFEND;
          request_complete := TRUE;
        ELSE
          nap$gt_releas_exclusiv_to_clist;
          osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface,
                internal_status);
        IFEND;
      WHILEND;
      osp$pop_inhibit_job_recovery;
      osp$disestablish_cond_handler;
      IF NOT internal_status.normal THEN
        status := internal_status;
      IFEND;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$data_area_too_small, external_interface, status);
    IFEND;
  PROCEND nap$gt_receive_connection_event;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_deliver_event_handler', EJECT ??
*copy nah$gt_deliver_event_handler

  PROCEDURE [XDCL] nap$gt_deliver_event_handler
    (    originator: ost$global_task_id;
         signal: pmt$signal);

    VAR
      cl_connection: ^nlt$cl_connection,
      connection: ^nat$gt_connection,
      condition_cause: nat$gt_condition_cause;

?? NEWTITLE := 'terminate_delivery', EJECT ??

    PROCEDURE terminate_delivery
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        activity_status: ^ost$activity_status,
        status: ost$status;

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
{Debug Code
      = pmc$block_exit_processing =
        osp$decrement_locked_variable (nav$namve_tsk_hndl_active_count, 1, actual_value, ignore_error);
{End Debug Code
      = pmc$system_conditions, mmc$segment_access_condition =
        IF (condition_cause = nac$gt_application_data) THEN
          IF cl_connection <> NIL THEN
            nlp$cl_deactivate_receiver (cl_connection);
            IF ((connection^.receiver_request.application_buffer.description_kind = nac$gt_allocated) AND
                  (connection^.receiver_request.application_buffer.allocated_description <> NIL)) THEN
              FREE connection^.receiver_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            IFEND;
            activity_status := connection^.receiver_request.activity_status;
            connection^.receiver_request := nav$gt_null_receiver_request;
            CASE connection^.state OF
            = nac$gt_open =
              ;
            = nac$gt_accept_received =
              connection^.state := nac$gt_open;
            = nac$gt_peer_reject, nac$gt_peer_disconnect, nac$gt_connection_failed =
              connection^.state := nac$gt_closed;
              nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
            CASEND;
            osp$establish_condition_handler (^terminate_delivery, FALSE);
            condition_cause := nac$gt_activity_status;
            #SPOIL (condition_cause);
            activity_status^.complete := TRUE;
            osp$set_status_from_condition (nac$status_id, condition, sa, activity_status^.status, status);
            nlp$cl_release_exclusive_access (cl_connection);
            osp$pop_inhibit_job_recovery;
            EXIT nap$gt_deliver_event_handler;
          IFEND;
        ELSE
          IF cl_connection <> NIL THEN
            IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task =
                  processing_task) THEN
              nlp$cl_deactivate_receiver (cl_connection);
              IF ((connection^.receiver_request.application_buffer.description_kind = nac$gt_allocated) AND
                    (connection^.receiver_request.application_buffer.allocated_description <> NIL)) THEN
                FREE connection^.receiver_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              IFEND;
              connection^.receiver_request := nav$gt_null_receiver_request;
            IFEND;
            IF cl_connection^.message_sender.active AND (cl_connection^.message_sender.task = processing_task)
                  THEN
              nlp$cl_deactivate_sender (cl_connection);
              IF ((connection^.sender_request.application_buffer.description_kind = nac$gt_allocated) AND
                    (connection^.sender_request.application_buffer.allocated_description <> NIL)) THEN
                FREE connection^.sender_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              IFEND;
              connection^.sender_request := nav$gt_null_sender_request;
            IFEND;
            nlp$cl_release_exclusive_access (cl_connection);
          IFEND;
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;

    PROCEND terminate_delivery;
?? OLDTITLE, EJECT ??

    VAR
      cl_connection_id: ^nlt$cl_connection_id,
      connection_exists: boolean,
      layer_active: boolean,
      processing_task: ost$global_task_id,
      data_delivery_in_progress: boolean,
      delivery_complete: boolean,
      connection_id: nat$gt_connection_id,
      job_connection: ^nat$gt_job_connection,
      termination_state: nac$gt_peer_reject .. nac$gt_connection_failed,
      data_length: nat$data_length,
      termination_event: nlt$ta_event,
      activity_status: ^ost$activity_status;

{Debug Code
    VAR
      actual_value: integer,
      ignore_error: boolean;

    osp$increment_locked_variable (nav$namve_tsk_hndl_active_count, 0, actual_value);
    IF actual_value > 1 THEN
      osp$increment_locked_variable (nav$multiple_namve_hndler_calls, 0, actual_value);
      IF nav$debug_mode > nac$no_debug THEN
        nap$namve_system_error (TRUE {=recoverable},
              'NAP$GT_DELIVER_EVENT_HANDLER invoked while another handler active.', NIL);
      IFEND;
    IFEND;
{End Debug Code

    cl_connection_id := #LOC (signal.contents);
    cl_connection := NIL;
    condition_cause := nac$gt_request_not_cause;
    #SPOIL (condition_cause, cl_connection);
    osp$push_inhibit_job_recovery;
*IF FALSE
    osp$establish_condition_handler (^terminate_delivery, FALSE);
*IFEND
{Debug Code
    osp$establish_condition_handler (^terminate_delivery, TRUE);
{End Debug Code

    nlp$cl_get_exclusive_via_cid (cl_connection_id^, connection_exists, cl_connection);
    IF connection_exists THEN
      nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active, connection);
      IF layer_active THEN
        pmp$get_executing_task_gtid (processing_task);
        IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task = processing_task)
              THEN
          data_delivery_in_progress := connection^.receiver_request.data_delivery_in_progress;
          condition_cause := nac$gt_application_data;
          #SPOIL (condition_cause);
          deliver_connection_events (connection, cl_connection, delivery_complete);
          condition_cause := nac$gt_request_not_cause;
          #SPOIL (condition_cause);
          nlp$ta_report_undelivered_data (cl_connection, connection^.undelivered_message_buffers);
          IF delivery_complete THEN
            activity_status := connection^.receiver_request.activity_status;
            connection^.receiver_request := nav$gt_null_receiver_request;
            nlp$cl_deactivate_receiver (cl_connection);
            CASE connection^.state OF
            = nac$gt_open =
              condition_cause := nac$gt_activity_status;
              #SPOIL (condition_cause);
              activity_status^.complete := TRUE;
              nlp$cl_release_exclusive_access (cl_connection);
            = nac$gt_accept_received =
              connection^.state := nac$gt_open;
              condition_cause := nac$gt_activity_status;
              #SPOIL (condition_cause);
              activity_status^.complete := TRUE;
              nlp$cl_release_exclusive_access (cl_connection);
            = nac$gt_peer_reject, nac$gt_peer_disconnect, nac$gt_connection_failed =
              connection_id := connection^.external_connection_id;
              IF NOT data_delivery_in_progress THEN
                connection^.state := nac$gt_closed;
                nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
                nlp$cl_release_exclusive_access (cl_connection);
                nap$gt_get_exclusive_to_clist;
                job_connection := nav$gt_job_connection_list.first_connection;
                WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
                  job_connection := job_connection^.next_connection;
                WHILEND;
                IF job_connection <> NIL THEN
                  delete_connection_from_sap (connection_id, job_connection^.sap_id);
                  nap$gt_delete_job_connection (connection_id);
                IFEND;
                nap$gt_releas_exclusiv_to_clist;
              ELSE
                termination_state := connection^.state;
                data_length := connection^.event_queue.beginning^.data_length;
                termination_event := connection^.event_queue.beginning^.event;
                FREE connection^.event_queue.beginning IN nav$network_paged_heap^;
                connection^.state := nac$gt_closed;
                nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
                nlp$cl_release_exclusive_access (cl_connection);

                nap$gt_get_exclusive_to_clist;
                job_connection := nav$gt_job_connection_list.first_connection;
                WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
                  job_connection := job_connection^.next_connection;
                WHILEND;
                IF job_connection <> NIL THEN
                  nap$gt_deactivate_job_connect (termination_state, termination_event, data_length,
                        job_connection);
                ELSE
                  CASE termination_state OF
                  = nac$gt_peer_disconnect =
                    nlp$bm_release_message (termination_event.osi_disconnect.data);
                  = nac$gt_connection_failed =
                    ;
                  ELSE
                  CASEND;
                IFEND;
                nap$gt_releas_exclusiv_to_clist;
              IFEND;
              condition_cause := nac$gt_activity_status;
              #SPOIL (condition_cause);
              activity_status^.complete := TRUE;
            CASEND;
          ELSE
            nlp$cl_release_exclusive_access (cl_connection);
          IFEND;
        ELSEIF cl_connection^.message_receiver.active THEN
          activate_receiver_task (cl_connection);
          nlp$cl_release_exclusive_access (cl_connection);
        ELSE
          nlp$cl_release_exclusive_access (cl_connection);
        IFEND;
      ELSE
        nlp$cl_release_exclusive_access (cl_connection);
      IFEND;
    IFEND;
    osp$pop_inhibit_job_recovery;

{Debug Code
    osp$disestablish_cond_handler;
    osp$decrement_locked_variable (nav$namve_tsk_hndl_active_count, 1, actual_value, ignore_error);
{End Debug Code

  PROCEND nap$gt_deliver_event_handler;
?? OLDTITLE ??
?? NEWTITLE := 'deliver_connect_event', EJECT ??

  PROCEDURE deliver_connect_event
    (    sap: ^nat$gt_sap;
         connect_request: nat$gt_connect_request;
         connection_id: nat$gt_connection_id;
         buffer_description: ^nlt$al_data_description;
         connect_event: ^nat$gt_connect_event);

{
{   ENTRY REQUIREMENT: the process of delivering connect events is dependent on the caller having a
{                      condition handler established to field conditions arising from an invalid user
{                      data area.  Further, it is expected that the condition handler rejects the connect
{                      request and releases any buffer resources associated with the connect request if
{                      such condition occurs.
{

    VAR
      message_id: nlt$bm_message_id,
      ignore_rbc: nat$data_length,
      ignore_dmb: nat$data_length;

    connect_event^.sap_id := sap^.sap_id;
    connect_event^.data_length := connect_request.data_length;
    connect_event^.source := connect_request.source;
    connect_event^.connection := connection_id;
    connect_event^.checksum := connect_request.checksum;
    connect_event^.expedited_data := connect_request.expedited_data;
    message_id := connect_request.data;
    IF connect_request.data_length > 0 THEN
      nlp$al_deliver_data (message_id, buffer_description^, ignore_rbc, ignore_dmb);
    IFEND;
  PROCEND deliver_connect_event;
?? OLDTITLE ??
?? NEWTITLE := 'establish_inbound_connection', EJECT ??

  PROCEDURE establish_inbound_connection
    (    sap: ^nat$gt_sap;
         cl_connection: ^nlt$cl_connection;
         connection: ^nat$gt_connection;
     VAR connection_id: nat$gt_connection_id);

    VAR
      job_connection: ^nat$gt_job_connection,
      sap_connection: ^nat$gt_sap_connection,
      layer_active: boolean;

    REPEAT
      ALLOCATE sap_connection IN nav$network_paged_heap^;
      IF sap_connection = NIL THEN
        syp$cycle;
      IFEND;
    UNTIL sap_connection <> NIL;
    nap$gt_create_job_connection (sap^.sap_id, cl_connection^.identifier, job_connection);
    connection_id := job_connection^.connection_id;
    connection^.state := nac$gt_connect_req_delivered;
    connection^.external_connection_id := job_connection^.connection_id;
    sap_connection^.connection_id := job_connection^.connection_id;
    sap_connection^.next_connection := sap^.first_connection;
    sap_connection^.sap_id := sap^.sap_id;
    sap^.first_connection := sap_connection;
  PROCEND establish_inbound_connection;
?? OLDTITLE ??
?? NEWTITLE := 'get_connect_request', EJECT ??

  PROCEDURE get_connect_request
    (    sap: ^nat$gt_sap;
     VAR connect_request_found: boolean;
     VAR connect_request: nat$gt_connect_request;
     VAR cl_connection: ^nlt$cl_connection;
     VAR connection: ^nat$gt_connection);

    VAR
      cl_connection_id: nlt$cl_connection_id,
      connect_indication: ^nat$gt_connect_request;

    connect_request_found := FALSE;
    REPEAT
      IF sap^.connect_request_queue.beginning <> NIL THEN
        connect_indication := sap^.connect_request_queue.beginning;
        cl_connection_id := connect_indication^.connection_id;
        sap^.connect_request_queue.beginning := sap^.connect_request_queue.beginning^.next_connect_request;
        nlp$cl_get_exclusive_via_cid (cl_connection_id, connect_request_found, cl_connection);
        IF connect_request_found THEN
          nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, connect_request_found,
                connection);
          IF connect_request_found THEN
            connect_request := connect_indication^;
            FREE connect_indication IN nav$network_paged_heap^;
          ELSE
            nlp$cl_release_exclusive_access (cl_connection);
            nlp$bm_release_message (connect_indication^.data);
            FREE connect_indication IN nav$network_paged_heap^;
          IFEND;
        ELSE
          nlp$bm_release_message (connect_indication^.data);
          FREE connect_indication IN nav$network_paged_heap^;
        IFEND;
      IFEND;
    UNTIL (connect_request_found OR (sap^.connect_request_queue.beginning = NIL));
    IF sap^.connect_request_queue.beginning = NIL THEN
      sap^.connect_request_queue.ending := NIL;
      nlp$cancel_timer (sap^.event_timer);
    ELSE
      nlp$select_timer (nac$gt_sap_event_timer_duration, 0, sap^.event_timer);
    IFEND;
  PROCEND get_connect_request;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_receive_connect_event'??
?? NEWTITLE := 'terminate_receive', EJECT ??
*copy nah$gt_receive_connect_event

  PROCEDURE [XDCL, #GATE] nap$gt_receive_connect_event
    (    sap_id: nat$gt_sap_identifier,
         data_area: nat$data_fragments,
         wait: ost$wait;
     VAR connect_event: nat$gt_connect_event;
     VAR activity_status: ost$activity_status;
     VAR status: ost$status);

    VAR
      cl_connection: ^nlt$cl_connection,
      connect_request: nat$gt_connect_request;


    PROCEDURE terminate_receive
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        status: ost$status;

      nap$condition_handler_trace (condition, sa);
      condition_status.normal := TRUE;
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        IF cl_connection <> NIL THEN
          nlp$ta_disconnect_connection (cl_connection, connect_request.data, condition_status);
          nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
          nlp$cl_clear_exclusive_access (cl_connection);
        IFEND;
        clear_sap_access;
        nap$gt_clear_exclusive_to_clist;
        osp$pop_inhibit_job_recovery;
        osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
        EXIT nap$gt_receive_connect_event;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_receive;
?? OLDTITLE, EJECT ??

    VAR
      buffer_length: integer,
      description_upperbound: integer,
      sap: ^nat$gt_sap,
      connect_request_found: boolean,
      connection: ^nat$gt_connection,
      connection_id: nat$gt_connection_id,
      buffer_description: ^nlt$al_data_description,
      requesting_task: ost$global_task_id,
      request_complete: boolean,
      server_job: boolean,
      internal_status: ost$status;

    status.normal := TRUE;
    activity_status.complete := TRUE;
    activity_status.status.normal := TRUE;

    IF UPPERBOUND (data_area) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_requirements (data_area, buffer_length, description_upperbound);
    IF buffer_length > nac$max_data_length THEN
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, 'nac$max_data_length', status);
      RETURN;
    IFEND;
    IF buffer_length >= nac$gt_maximum_connect_data THEN
      cl_connection := NIL;
      #SPOIL (cl_connection);
      osp$establish_condition_handler (^terminate_receive, FALSE);
      osp$push_inhibit_job_recovery;
      request_complete := FALSE;
      internal_status.normal := TRUE;
      WHILE NOT request_complete AND internal_status.normal DO
        nap$gt_get_exclusive_to_clist;
        get_sap_access (sap_id, sap, server_job, internal_status);
        IF internal_status.normal THEN
          IF server_job THEN
            IF NOT sap^.connect_request_receiver.active THEN
              get_connect_request (sap, connect_request_found, connect_request, cl_connection, connection);
              IF connect_request_found THEN
                establish_inbound_connection (sap, cl_connection, connection, connection_id);
                PUSH buffer_description: [1 .. description_upperbound];
                nlp$al_initialize_data_descrip (data_area, buffer_length, buffer_description^);
                deliver_connect_event (sap, connect_request, connection_id, buffer_description,
                      ^connect_event);
                nlp$select_timer (nac$gt_accept_timer_duration, 0, connection^.timer);
                nlp$cl_release_exclusive_access (cl_connection);
                release_sap_access;
                nap$gt_releas_exclusiv_to_clist;
                request_complete := TRUE;
              ELSE
                nap$gt_releas_exclusiv_to_clist;
                pmp$get_executing_task_gtid (requesting_task);
                sap^.connect_request_receiver.task := requesting_task;
                sap^.connect_request_receiver.activity_status := ^activity_status;
                sap^.connect_request_receiver.application_event := ^connect_event;
                IF description_upperbound <= nac$gt_fixed_fragments THEN
                  sap^.connect_request_receiver.application_buffer.description_kind := nac$gt_fixed;
                  nlp$al_initialize_data_descrip (data_area, buffer_length,
                        sap^.connect_request_receiver.application_buffer.fixed_description);
                ELSE
                  sap^.connect_request_receiver.application_buffer.description_kind := nac$gt_allocated;
                  REPEAT
                    ALLOCATE sap^.connect_request_receiver.application_buffer.allocated_description:
                          [1 .. description_upperbound] IN nav$network_paged_heap^;
                    IF sap^.connect_request_receiver.application_buffer.allocated_description = NIL THEN
                      syp$cycle;
                    IFEND;
                  UNTIL sap^.connect_request_receiver.application_buffer.allocated_description <> NIL;
                  nlp$al_initialize_data_descrip (data_area, buffer_length,
                        sap^.connect_request_receiver.application_buffer.allocated_description^);
                IFEND;
                sap^.connect_request_receiver.active := TRUE;
                activity_status.complete := FALSE;
                release_sap_access;
                IF wait = osc$wait THEN
                  pmp$wait (1000, 200);

                /wait_for_request_complete/
                  REPEAT
                    get_sap_access (sap_id, sap, server_job, internal_status);
                    IF internal_status.normal THEN
                      IF NOT sap^.connect_request_receiver.active OR
                            (sap^.connect_request_receiver.task <> requesting_task) THEN
                        request_complete := TRUE;
                        release_sap_access;
                      ELSE
                        release_sap_access;
                        pmp$wait (2000000, 2000000);
                      IFEND;
                    ELSE
                      request_complete := TRUE;
                    IFEND;
                  UNTIL request_complete;
                ELSE
                  request_complete := TRUE;
                IFEND;
              IFEND;
            ELSEIF wait = osc$wait THEN
              release_sap_access;
              nap$gt_releas_exclusiv_to_clist;
              pmp$wait (1000, 1000);
            ELSE
              release_sap_access;
              nap$gt_releas_exclusiv_to_clist;
              osp$set_status_abnormal (nac$status_id, nae$receive_outstanding, external_interface,
                    internal_status);
            IFEND;
          ELSE
            release_sap_access;
            nap$gt_releas_exclusiv_to_clist;
            osp$set_status_abnormal (nac$status_id, nae$client_receiving_connection, external_interface,
                  internal_status);
          IFEND;
        ELSE
          nap$gt_releas_exclusiv_to_clist;
        IFEND;
      WHILEND;
      osp$pop_inhibit_job_recovery;
      IF NOT internal_status.normal THEN
        status := internal_status;
      IFEND;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$data_area_too_small, external_interface, status);
    IFEND;
  PROCEND nap$gt_receive_connect_event;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_deliver_connect_handler', EJECT ??
*copy nah$gt_deliver_connect_handler

  PROCEDURE [XDCL] nap$gt_deliver_connect_handler
    (    originator: ost$global_task_id;
         signal: pmt$signal);

    VAR
      sap: ^nat$gt_sap,
      cl_connection: ^nlt$cl_connection,
      connect_request: nat$gt_connect_request,
      condition_cause: nat$gt_condition_cause;

?? NEWTITLE := 'terminate_delivery', EJECT ??

    PROCEDURE terminate_delivery
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        status: ost$status;

      nap$condition_handler_trace (condition, sa);
      condition_status.normal := TRUE;
      CASE condition.selector OF
{Debug Code
      = pmc$block_exit_processing =
        osp$decrement_locked_variable (nav$namve_tsk_hndl_active_count, 1, actual_value, ignore_error);
{End Debug Code
      = pmc$system_conditions, mmc$segment_access_condition =
        IF condition_cause = nac$gt_application_data THEN
          nlp$ta_disconnect_connection (cl_connection, connect_request.data, condition_status);
          nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
          nlp$cl_clear_exclusive_access (cl_connection);
          activity_status := sap^.connect_request_receiver.activity_status;
          sap^.connect_request_receiver := nav$gt_null_connect_rq_receiver;
          clear_sap_access;
          nap$gt_clear_exclusive_to_clist;
          osp$pop_inhibit_job_recovery;
          condition_cause := nac$gt_activity_status;
          #SPOIL (condition_cause);
          osp$establish_condition_handler (^terminate_delivery, FALSE);
          activity_status^.complete := TRUE;
          osp$set_status_from_condition (nac$status_id, condition, sa, activity_status^.status, status);
          EXIT nap$gt_deliver_connect_handler;
        ELSE
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_delivery;
?? OLDTITLE, EJECT ??

    VAR
      sap_id: ^nat$gt_sap_identifier,
      processing_task: ost$global_task_id,
      connect_request_found: boolean,
      connection: ^nat$gt_connection,
      connection_id: nat$gt_connection_id,
      buffer_description: ^nlt$al_data_description,
      application_event: ^nat$gt_connect_event,
      activity_status: ^ost$activity_status,
      server_job: boolean,
      status: ost$status;

{Debug Code
    VAR
      actual_value: integer,
      ignore_error: boolean;

    osp$increment_locked_variable (nav$namve_tsk_hndl_active_count, 0, actual_value);
    IF actual_value > 1 THEN
      osp$increment_locked_variable (nav$multiple_namve_hndler_calls, 0, actual_value);
      IF nav$debug_mode > nac$no_debug THEN
        nap$namve_system_error (TRUE {=recoverable},
              'NAP$GT_DELIVER_CONNECT_HANDLER invoked while another handler active.', NIL);
      IFEND;
    IFEND;
{End Debug Code

    sap_id := #LOC (signal.contents);
    condition_cause := nac$gt_request_not_cause;
    #SPOIL (condition_cause);
*IF FALSE
    osp$establish_condition_handler (^terminate_delivery, FALSE);
*IFEND
{Debug Code
    osp$establish_condition_handler (^terminate_delivery, TRUE);
{End Debug Code
    osp$push_inhibit_job_recovery;
    nap$gt_get_exclusive_to_clist;
    get_server_sap_access (sap_id^, sap, status);
    IF status.normal THEN
      pmp$get_executing_task_gtid (processing_task);
      IF sap^.connect_request_receiver.active AND (sap^.connect_request_receiver.task = processing_task) THEN
        get_connect_request (sap, connect_request_found, connect_request, cl_connection, connection);
        IF connect_request_found THEN
          establish_inbound_connection (sap, cl_connection, connection, connection_id);
          application_event := sap^.connect_request_receiver.application_event;
          activity_status := sap^.connect_request_receiver.activity_status;
          CASE sap^.connect_request_receiver.application_buffer.description_kind OF
          = nac$gt_fixed =
            PUSH buffer_description: [1 .. UPPERBOUND (sap^.connect_request_receiver.application_buffer.
                  fixed_description.fragment)];
            buffer_description^ := sap^.connect_request_receiver.application_buffer.fixed_description;
            sap^.connect_request_receiver := nav$gt_null_connect_rq_receiver;
            condition_cause := nac$gt_application_data;
            #SPOIL (condition_cause);
            deliver_connect_event (sap, connect_request, connection_id, buffer_description,
                  application_event);
          = nac$gt_allocated =
            PUSH buffer_description: [1 .. UPPERBOUND (sap^.connect_request_receiver.application_buffer.
                  allocated_description^.fragment)];
            buffer_description^ := sap^.connect_request_receiver.application_buffer.allocated_description^;
            FREE sap^.connect_request_receiver.application_buffer.allocated_description IN
                  nav$network_paged_heap^;
            sap^.connect_request_receiver := nav$gt_null_connect_rq_receiver;
            condition_cause := nac$gt_application_data;
            #SPOIL (condition_cause);
            deliver_connect_event (sap, connect_request, connection_id, buffer_description,
                  application_event);
          CASEND;
          condition_cause := nac$gt_request_not_cause;
          #SPOIL (condition_cause);
          nlp$select_timer (nac$gt_accept_timer_duration, 0, connection^.timer);
          nlp$cl_release_exclusive_access (cl_connection);
          release_sap_access;
          nap$gt_releas_exclusiv_to_clist;
          condition_cause := nac$gt_activity_status;
          #SPOIL (condition_cause);
          activity_status^.complete := TRUE;
        ELSE
          release_sap_access;
          nap$gt_releas_exclusiv_to_clist;
        IFEND;
      ELSE
        release_sap_access;
        nap$gt_releas_exclusiv_to_clist;
      IFEND;
    ELSE
      nap$gt_releas_exclusiv_to_clist;
    IFEND;
    osp$pop_inhibit_job_recovery;

{Debug Code
    osp$disestablish_cond_handler;
    osp$decrement_locked_variable (nav$namve_tsk_hndl_active_count, 1, actual_value, ignore_error);
{End Debug Code

  PROCEND nap$gt_deliver_connect_handler;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_reject_connection', EJECT ??
*copy nah$gt_reject_connection

  PROCEDURE [XDCL, #GATE] nap$gt_reject_connection
    (    connection_id: nat$gt_connection_id,
         data: nat$data_fragments;
     VAR status: ost$status);

    VAR
      cl_connection: ^nlt$cl_connection,
      condition_cause: nat$gt_condition_cause;

?? NEWTITLE := 'terminate_reject_connection', EJECT ??

    PROCEDURE terminate_reject_connection
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        IF condition_cause = nac$gt_application_data THEN
          nlp$cl_clear_exclusive_access (cl_connection);
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
          EXIT nap$gt_reject_connection;
        ELSE
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_reject_connection;
?? OLDTITLE, EJECT ??

    VAR
      connection_to_delete: ^nat$gt_job_connection,
      connection: ^nat$gt_connection,
      data_length: nat$data_length,
      message_id: nlt$bm_message_id,
      internal_status: ost$status;

    status.normal := TRUE;

    IF UPPERBOUND (data) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_length (data, data_length);
    IF data_length <= nac$gt_maximum_disconnect_data THEN
      condition_cause := nac$gt_request_not_cause;
      #SPOIL (condition_cause);
      osp$establish_condition_handler (^terminate_reject_connection, FALSE);
      osp$push_inhibit_job_recovery;
      nap$gt_get_exclusive_to_clist;
      get_connection_to_delete (connection_id, connection_to_delete, cl_connection, connection,
            internal_status);
      IF internal_status.normal THEN
        IF connection^.state = nac$gt_connect_req_delivered THEN
          delete_connection_from_sap (connection_id, connection_to_delete^.sap_id);
          nap$gt_delete_job_connection (connection_id);
          nap$gt_releas_exclusiv_to_clist;
          connection^.state := nac$gt_closed;
          nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
          condition_cause := nac$gt_application_data;
          #SPOIL (condition_cause);
          nlp$bm_create_message (data, message_id, internal_status);
          condition_cause := nac$gt_request_not_cause;
          #SPOIL (condition_cause);
          nlp$ta_disconnect_connection (cl_connection, message_id, internal_status);
          nlp$cl_release_exclusive_access (cl_connection);
        ELSE
          nap$gt_releas_exclusiv_to_clist;
          nlp$cl_release_exclusive_access (cl_connection);
          osp$set_status_abnormal (nac$status_id, nae$connection_not_proposed, external_interface,
                internal_status);
        IFEND;
      ELSE
        nap$gt_releas_exclusiv_to_clist;
      IFEND;
      osp$pop_inhibit_job_recovery;
      IF NOT internal_status.normal THEN
        osp$disestablish_cond_handler;
        status := internal_status;
      IFEND;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, external_interface, status);
    IFEND;
  PROCEND nap$gt_reject_connection;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_request_connection', EJECT ??
*copy nah$gt_request_connection

  PROCEDURE [XDCL, #GATE] nap$gt_request_connection
    (    sap_id: nat$gt_sap_identifier,
         destination: nat$network_address,
         data: nat$data_fragments;
         options: ^nat$gt_connection_options;
         preferred_protocol_class: nat$ta_preferred_protocol_class;
         alternate_protocol_class: nat$ta_alternate_protocol_class;
     VAR connection_id: nat$gt_connection_id;
     VAR status: ost$status);

?? NEWTITLE := 'terminate_request_connection', EJECT ??

    PROCEDURE terminate_request_connection
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        IF condition_cause = nac$gt_application_data THEN
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
          EXIT nap$gt_request_connection;
        ELSE
          osp$pop_inhibit_job_recovery;
          nap$gt_clear_exclusive_to_slist;
          nap$gt_clear_exclusive_to_clist;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      = pmc$block_exit_processing =
        IF condition_cause = nac$gt_task_termination THEN
          IF cl_connection <> NIL THEN
            nlp$cl_deactivate_layer (nlc$osi_generic_xport_interface, cl_connection);
            nlp$cl_clear_exclusive_access (cl_connection);
          IFEND;
          osp$pop_inhibit_job_recovery;
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_request_connection;
?? OLDTITLE, EJECT ??

    VAR
      active_sap: ^^nat$gt_sap,
      actual_destination_address: ^SEQ ( * ),
      checksum: boolean,
      condition_cause: nat$gt_condition_cause,
      connection: ^nat$gt_connection,
      cl_connection: ^nlt$cl_connection,
      data_length: nat$data_length,
      destination_network_address: ^SEQ ( * ),
      empty_message: nlt$bm_message_id,
      expedited_data: boolean,
      i: integer,
      ignore_layer_active: boolean,
      internal_status: ost$status,
      job_connection: ^nat$gt_job_connection,
      job_sap: ^nat$gt_job_sap,
      message_id: nlt$bm_message_id,
      sap_found: boolean,
      selector: nat$gt_sap_identifier,
      sap_connection: ^nat$gt_sap_connection;

    status.normal := TRUE;
    cl_connection := NIL;
    #SPOIL (cl_connection);

    IF UPPERBOUND (data) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_length (data, data_length);
    IF data_length > nac$gt_maximum_connect_data THEN
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, external_interface, status);
      RETURN;
    IFEND;

    checksum := FALSE;
    expedited_data := FALSE;
    IF options <> NIL THEN
      FOR i := LOWERBOUND (options^) TO UPPERBOUND (options^) DO
        CASE options^ [i].kind OF
        = nac$gt_checksum =
          checksum := options^ [i].checksum;
        = nac$gt_expedited_data =
          expedited_data := options^ [i].expedited_data;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$invalid_selector, external_interface, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'OPTIONS', status);
          osp$append_status_integer (osc$status_parameter_delimiter, i, 10, TRUE, status);
          RETURN;
        CASEND;
      FOREND;
    IFEND;

    IF (destination.kind <> nac$osi_transport_address) AND
          (destination.kind <> nac$osi_non_cdna_transport_addr) THEN
      osp$set_status_condition (nae$unsupported_address, status);
      RETURN;
    IFEND;

    destination_network_address := ^destination.osi_transport_address.network_address;
    RESET destination_network_address;
    IF (destination.osi_transport_address.network_address_length <= 0) OR
          (destination.osi_transport_address.network_address_length > nac$osi_max_network_address_len) THEN
      osp$set_status_condition (nae$unsupported_address, status);
      RETURN;
    IFEND;
    NEXT actual_destination_address: [[REP destination.osi_transport_address.network_address_length OF
          cell]] IN destination_network_address;
    IF actual_destination_address = NIL THEN
      osp$set_status_condition (nae$unsupported_address, status);
      RETURN;
    IFEND;

    condition_cause := nac$gt_application_data;
    #SPOIL (condition_cause);
    osp$establish_condition_handler (^terminate_request_connection, TRUE);
    osp$push_inhibit_job_recovery;
    nlp$bm_create_message (data, message_id, internal_status);
    condition_cause := nac$gt_request_not_cause;
    #SPOIL (condition_cause);
    nap$gt_get_exclusive_to_slist;
    job_sap := nav$gt_job_sap_list.first_sap;
    WHILE (job_sap <> NIL) AND (job_sap^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      job_sap := job_sap^.next_sap;
    WHILEND;
    IF job_sap <> NIL THEN
      selector := job_sap^.selector;
      nap$gt_releas_exclusiv_to_slist;
      nlp$cl_create_connection (nlc$osi_generic_xport_interface, cl_connection);
      IF cl_connection <> NIL THEN
        nlp$cl_activate_layer (nlc$osi_generic_xport_interface, cl_connection);
        nlp$cl_get_layer_connection (nlc$osi_generic_xport_interface, cl_connection, ignore_layer_active,
              connection);
        condition_cause := nac$gt_task_termination;
        #SPOIL (condition_cause);
        nlp$ta_request_connection (cl_connection, selector.osi_sap_identifier, checksum, message_id,
              destination.osi_transport_address.transport_sap_selector
              (1, destination.osi_transport_address.transport_sap_selector_length),
              actual_destination_address^, destination.kind = nac$osi_transport_address,
              expedited_data, sap_priority(sap_id), preferred_protocol_class, alternate_protocol_class,
              {quality_of_service =} NIL, internal_status);
        condition_cause := nac$gt_request_not_cause;
        #SPOIL (condition_cause);
        IF internal_status.normal THEN
          nap$gt_get_exclusive_to_clist;
          nap$gt_get_exclusive_to_slist;
          job_sap := nav$gt_job_sap_list.first_sap;
          WHILE (job_sap <> NIL) AND (job_sap^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
            job_sap := job_sap^.next_sap;
          WHILEND;
          IF job_sap <> NIL THEN
            nap$gt_create_job_connection (sap_id, cl_connection^.identifier, job_connection);
            connection^ := nav$gt_null_connection;
            connection^.state := nac$gt_connect_request_sent;
            connection^.external_connection_id := job_connection^.connection_id;
            connection^.sap_id := selector;
            connection_id := job_connection^.connection_id;
            nlp$cl_release_exclusive_access (cl_connection);
            REPEAT
              ALLOCATE sap_connection IN nav$network_paged_heap^;
              IF sap_connection = NIL THEN
                syp$cycle;
              IFEND;
            UNTIL sap_connection <> NIL;
            sap_connection^.connection_id := job_connection^.connection_id;
            osp$begin_subsystem_activity;
            osp$set_job_signature_lock (nav$gt_sap_list.lock);
            find_active_sap (selector, active_sap, sap_found);
            sap_connection^.next_connection := active_sap^^.first_connection;
            active_sap^^.first_connection := sap_connection;
            osp$clear_job_signature_lock (nav$gt_sap_list.lock);
            osp$end_subsystem_activity;
          ELSE
            nlp$bm_create_message (nav$gt_null_message, empty_message, {ignore} internal_status);
            nlp$ta_disconnect_connection (cl_connection, empty_message, {ignore} internal_status);
            connection^.state := nac$gt_closed;
            nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
            nlp$cl_release_exclusive_access (cl_connection);
            osp$set_status_abnormal (nac$status_id, nae$sap_not_open, external_interface, internal_status);
          IFEND;
          nap$gt_releas_exclusiv_to_slist;
          nap$gt_releas_exclusiv_to_clist;
        ELSE
          nlp$cl_deactivate_layer (nlc$osi_generic_xport_interface, cl_connection);
          nlp$cl_release_exclusive_access (cl_connection);
          osp$set_status_condition (nae$destination_not_reachable, internal_status);
        IFEND;
      ELSE
        nlp$bm_release_message (message_id);
        osp$set_status_condition (nae$namve_max_connection_limit, internal_status);
      IFEND;
    ELSE
      nap$gt_releas_exclusiv_to_slist;
      nlp$bm_release_message (message_id);
      osp$set_status_abnormal (nac$status_id, nae$sap_not_open, external_interface, internal_status);
    IFEND;
    osp$pop_inhibit_job_recovery;
    osp$disestablish_cond_handler;
    IF NOT internal_status.normal THEN
      status := internal_status;
    IFEND;

  PROCEND nap$gt_request_connection;
?? OLDTITLE ??
?? NEWTITLE := 'send_data', EJECT ??

  PROCEDURE send_data
    (    cl_connection: ^nlt$cl_connection;
         connection: ^nat$gt_connection;
         current_connection_capacity: nat$data_length);

{
{   ENTRY REQUIREMENT: the process of sending data events is dependent on the caller having a condition
{                      handler established to field conditions arising from an invalid user data area.
{                      Further, it is expected that the condition handler performs the necessary actions
{                      to clean-up the outstanding request and report status to its user if such condition
{                      occurs.
{

    VAR
      data: ^array [1 .. * ] of nat$data_fragment,
      description_upperbound: integer,
      end_of_message: boolean,
      fragment_size: nat$data_length,
      ignore_rb: integer,
      ignore_status: ost$status,
      message: nlt$bm_message_id;

    IF current_connection_capacity > connection^.sender_request.remaining_bytes_to_send THEN
      fragment_size := connection^.sender_request.remaining_bytes_to_send;
    ELSE
      fragment_size := current_connection_capacity;
    IFEND;

    CASE connection^.sender_request.application_buffer.description_kind OF
    = nac$gt_fixed =
      nlp$al_get_data_requirements (connection^.sender_request.application_buffer.fixed_description.fragment,
            ignore_rb, description_upperbound);
      PUSH data: [1 .. description_upperbound];
      nlp$al_fragment_data (fragment_size, connection^.sender_request.application_buffer.fixed_description,
            connection^.sender_request.remaining_bytes_to_send, data^);
    = nac$gt_allocated =
      nlp$al_get_data_requirements (connection^.sender_request.application_buffer.allocated_description^.
            fragment, ignore_rb, description_upperbound);
      PUSH data: [1 .. description_upperbound];
      nlp$al_fragment_data (fragment_size, connection^.sender_request.application_buffer.
            allocated_description^, connection^.sender_request.remaining_bytes_to_send, data^);
      IF connection^.sender_request.remaining_bytes_to_send = 0 THEN
        FREE connection^.sender_request.application_buffer.allocated_description IN nav$network_paged_heap^;
      IFEND;
    CASEND;
    IF connection^.sender_request.remaining_bytes_to_send = 0 THEN
      nlp$cl_deactivate_sender (cl_connection);
      end_of_message := connection^.sender_request.end_of_message;
    ELSE
      end_of_message := FALSE;
    IFEND;
    nlp$bm_create_message (data^, message, ignore_status);
    nlp$ta_send_data (cl_connection, message, end_of_message, ignore_status);
  PROCEND send_data;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_send_data', EJECT ??
*copy nah$gt_send_data

  PROCEDURE [XDCL, #GATE] nap$gt_send_data
    (    connection_id: nat$gt_connection_id;
         data: nat$data_fragments;
         end_of_message: boolean;
         wait: ost$wait;
     VAR activity_status: ost$activity_status;
     VAR status: ost$status);

    VAR
      cl_connection: ^nlt$cl_connection,
      condition_cause: nat$gt_condition_cause,
      connection: ^nat$gt_connection;

?? NEWTITLE := 'terminate_send', EJECT ??

    PROCEDURE terminate_send
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        requesting_task: ost$global_task_id;

      nap$condition_handler_trace (condition, sa);
      condition_status.normal := TRUE;
      CASE condition.selector OF
      = pmc$system_conditions, mmc$segment_access_condition =
        IF condition_cause = nac$gt_application_data THEN
          pmp$get_executing_task_gtid (requesting_task);
          IF cl_connection^.message_sender.active AND (cl_connection^.message_sender.task = requesting_task)
                THEN
            nlp$cl_deactivate_sender (cl_connection);
            IF ((connection^.sender_request.application_buffer.description_kind = nac$gt_allocated) AND
                  (connection^.sender_request.application_buffer.allocated_description <> NIL)) THEN
              FREE connection^.sender_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            IFEND;
            connection^.sender_request := nav$gt_null_sender_request;
          IFEND;
          nlp$cl_release_exclusive_access (cl_connection);
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
          EXIT nap$gt_send_data;
        ELSE
          IF cl_connection <> NIL THEN
            nlp$cl_release_exclusive_access (cl_connection);
          IFEND;
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_send;
?? OLDTITLE, EJECT ??

    VAR
      capacity: nat$data_length,
      connection_exists: boolean,
      description_upperbound: integer,
      internal_status: ost$status,
      layer_active: boolean,
      message_id: nlt$bm_message_id,
      requesting_task: ost$global_task_id,
      request_complete: boolean,
      send_data_length: integer;

    status.normal := TRUE;
    activity_status.status.normal := TRUE;
    activity_status.complete := TRUE;

    IF UPPERBOUND (data) > nac$max_data_fragment_count THEN
      osp$set_status_condition (nae$maximum_data_fragments, status);
      RETURN;
    IFEND;

    nlp$al_get_data_requirements (data, send_data_length, description_upperbound);
    IF send_data_length > nac$max_data_length THEN
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, 'nac$max_data_length', status);
      RETURN;
    IFEND;

    osp$push_inhibit_job_recovery;
    cl_connection := NIL;
    condition_cause := nac$gt_request_not_cause;
    #SPOIL (condition_cause, cl_connection);
    osp$establish_condition_handler (^terminate_send, FALSE);
    request_complete := FALSE;
    internal_status.normal := TRUE;

{ Loop until the connection lock is captured or until a current send has completed if wait is specified.

    WHILE NOT request_complete AND internal_status.normal DO
      get_connection_access (connection_id, cl_connection, connection, internal_status);
      IF internal_status.normal THEN
        IF connection^.state = nac$gt_open THEN
          IF NOT cl_connection^.message_sender.active THEN
            condition_cause := nac$gt_application_data;
            #SPOIL (condition_cause);
            nlp$al_get_data_requirements (data, send_data_length, description_upperbound);
            connection^.sender_request.remaining_bytes_to_send := send_data_length;
            nlp$osi_get_outbound_capacity (cl_connection, capacity);
            IF (capacity > 0) AND (capacity >= connection^.sender_request.remaining_bytes_to_send) THEN
              nlp$bm_create_message (data, message_id, {ignore_status} internal_status);
              nlp$ta_send_data (cl_connection, message_id, end_of_message, internal_status);
              condition_cause := nac$gt_request_not_cause;
              #SPOIL (condition_cause);
              nlp$cl_release_exclusive_access (cl_connection);
              request_complete := TRUE;
            ELSE
              nlp$cl_activate_sender (cl_connection);
              connection^.sender_request.end_of_message := end_of_message;
              connection^.sender_request.activity_status := ^activity_status;
              condition_cause := nac$gt_application_data;
              #SPOIL (condition_cause);
              IF description_upperbound <= nac$gt_fixed_fragments THEN
                connection^.sender_request.application_buffer.description_kind := nac$gt_fixed;
                nlp$al_initialize_data_descrip (data, connection^.sender_request.remaining_bytes_to_send,
                      connection^.sender_request.application_buffer.fixed_description);
              ELSE
                connection^.sender_request.application_buffer.description_kind := nac$gt_allocated;
                REPEAT
                  ALLOCATE connection^.sender_request.application_buffer.allocated_description:
                        [1 .. description_upperbound] IN nav$network_paged_heap^;
                  IF connection^.sender_request.application_buffer.allocated_description = NIL THEN
                    syp$cycle;
                  IFEND;
                UNTIL connection^.sender_request.application_buffer.allocated_description <> NIL;
                nlp$al_initialize_data_descrip (data, connection^.sender_request.remaining_bytes_to_send,
                      connection^.sender_request.application_buffer.allocated_description^);
              IFEND;

              WHILE (capacity > 0) AND (connection^.sender_request.remaining_bytes_to_send > 0) DO
                send_data (cl_connection, connection, capacity);
                nlp$osi_get_outbound_capacity (cl_connection, capacity);
              WHILEND;

              condition_cause := nac$gt_request_not_cause;
              #SPOIL (condition_cause);
              pmp$get_executing_task_gtid (requesting_task);
              nlp$cl_release_exclusive_access (cl_connection);
              IF connection^.sender_request.remaining_bytes_to_send > 0 THEN
                activity_status.complete := FALSE;
                IF (wait = osc$wait) THEN

                /wait_for_request_complete/
                  WHILE NOT request_complete DO
                    pmp$wait (1000, 100);
                    get_connection_access (connection_id, cl_connection, connection, internal_status);
                    IF internal_status.normal THEN
                      IF NOT cl_connection^.message_sender.active OR
                            (cl_connection^.message_sender.task <> requesting_task) THEN
                        request_complete := TRUE;
                      IFEND;
                      nlp$cl_release_exclusive_access (cl_connection);
                    ELSE
                      request_complete := TRUE;
                    IFEND;
                  WHILEND /wait_for_request_complete/;
                ELSE
                  request_complete := TRUE;
                IFEND;
              ELSE { IF connection^.sender_request.remaining_bytes_to_send = 0 THEN
                request_complete := TRUE;
              IFEND;
            IFEND;
          ELSEIF wait = osc$wait THEN
            nlp$cl_release_exclusive_access (cl_connection);
            pmp$wait (1000, 1000)
          ELSE
            nlp$cl_release_exclusive_access (cl_connection);
            osp$set_status_abnormal (nac$status_id, nae$send_outstanding, external_interface,
                  internal_status);
          IFEND;
        ELSE { The connection is not open.
          nlp$cl_release_exclusive_access (cl_connection);
          osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface,
                internal_status);
        IFEND;
      IFEND;
    WHILEND;
    osp$disestablish_cond_handler;
    osp$pop_inhibit_job_recovery;
    IF NOT internal_status.normal THEN
      status := internal_status;
    IFEND;
  PROCEND nap$gt_send_data;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_send_data_handler', EJECT ??
*copy nah$gt_send_data_handler

  PROCEDURE [XDCL] nap$gt_send_data_handler
    (    originator: ost$global_task_id;
         signal: pmt$signal);

    VAR
      condition_cause: nat$gt_condition_cause;

?? NEWTITLE := 'terminate_send', EJECT ??

    PROCEDURE terminate_send
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        activity_status: ^ost$activity_status,
        status: ost$status;

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
{Debug Code
      = pmc$block_exit_processing =
        osp$decrement_locked_variable (nav$namve_tsk_hndl_active_count, 1, actual_value, ignore_error);
{End Debug Code
      = pmc$system_conditions, mmc$segment_access_condition =
        IF condition_cause = nac$gt_application_data THEN
          activity_status := connection^.sender_request.activity_status;
          nlp$cl_deactivate_sender (cl_connection);
          IF ((connection^.sender_request.application_buffer.description_kind = nac$gt_allocated) AND
                (connection^.sender_request.application_buffer.allocated_description <> NIL)) THEN
            FREE connection^.sender_request.application_buffer.allocated_description IN
                  nav$network_paged_heap^;
          IFEND;
          connection^.sender_request := nav$gt_null_sender_request;
          osp$establish_condition_handler (^terminate_send, FALSE);
          condition_cause := nac$gt_activity_status;
          #SPOIL (condition_cause);
          activity_status^.complete := TRUE;
          osp$set_status_from_condition (nac$status_id, condition, sa, activity_status^.status,
                condition_status);
          nlp$cl_release_exclusive_access (cl_connection);
          osp$pop_inhibit_job_recovery;
          EXIT nap$gt_send_data_handler;
        ELSE
          IF cl_connection <> NIL THEN
            IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task =
                  processing_task) THEN
              nlp$cl_deactivate_receiver (cl_connection);
              IF ((connection^.receiver_request.application_buffer.description_kind = nac$gt_allocated) AND
                    (connection^.receiver_request.application_buffer.allocated_description <> NIL)) THEN
                FREE connection^.receiver_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              IFEND;
              connection^.receiver_request := nav$gt_null_receiver_request;
            IFEND;
            IF cl_connection^.message_sender.active AND (cl_connection^.message_sender.task = processing_task)
                  THEN
              nlp$cl_deactivate_sender (cl_connection);
              IF ((connection^.sender_request.application_buffer.description_kind = nac$gt_allocated) AND
                    (connection^.sender_request.application_buffer.allocated_description <> NIL)) THEN
                FREE connection^.sender_request.application_buffer.allocated_description IN
                      nav$network_paged_heap^;
              IFEND;
              connection^.sender_request := nav$gt_null_sender_request;
            IFEND;
            nlp$cl_release_exclusive_access (cl_connection);
          IFEND;
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_send;
?? OLDTITLE, EJECT ??

    VAR
      capacity: nat$data_length,
      cl_connection: ^nlt$cl_connection,
      cl_connection_id: ^nlt$cl_connection_id,
      connection: ^nat$gt_connection,
      connection_exists: boolean,
      layer_active: boolean,
      processing_task: ost$global_task_id;

{Debug Code
    VAR
      actual_value: integer,
      ignore_error: boolean;

    osp$increment_locked_variable (nav$namve_tsk_hndl_active_count, 0, actual_value);
    IF actual_value > 1 THEN
      osp$increment_locked_variable (nav$multiple_namve_hndler_calls, 0, actual_value);
      IF nav$debug_mode > nac$no_debug THEN
        nap$namve_system_error (TRUE {=recoverable},
              'NAP$GT_SEND_DATA_HANDLER invoked while another handler active.', NIL);
      IFEND;
    IFEND;
{End Debug Code

    cl_connection_id := #LOC (signal.contents);
    osp$push_inhibit_job_recovery;
    condition_cause := nac$gt_request_not_cause;
    cl_connection := NIL;
    #SPOIL (condition_cause, cl_connection);
*IF FALSE
    osp$establish_condition_handler (^terminate_send, FALSE);
*IFEND
{Debug Code
    osp$establish_condition_handler (^terminate_send, TRUE);
{End Debug Code
    nlp$cl_get_exclusive_via_cid (cl_connection_id^, connection_exists, cl_connection);
    IF connection_exists THEN
      nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active, connection);
      pmp$get_executing_task_gtid (processing_task);
      IF layer_active AND cl_connection^.message_sender.active AND
            (cl_connection^.message_sender.task = processing_task) THEN
        nlp$osi_get_outbound_capacity (cl_connection, capacity);
        IF (capacity > 0) THEN
          WHILE (capacity > 0) AND (connection^.sender_request.remaining_bytes_to_send > 0) DO
            condition_cause := nac$gt_application_data;
            #SPOIL (condition_cause);
            send_data (cl_connection, connection, capacity);
            condition_cause := nac$gt_request_not_cause;
            #SPOIL (condition_cause);
            nlp$osi_get_outbound_capacity (cl_connection, capacity);
          WHILEND;
          condition_cause := nac$gt_activity_status;
          #SPOIL (condition_cause);
          connection^.sender_request.activity_status^.complete :=
                connection^.sender_request.remaining_bytes_to_send = 0;
          condition_cause := nac$gt_request_not_cause;
          #SPOIL (condition_cause);
        IFEND;
      IFEND;
      nlp$cl_release_exclusive_access (cl_connection);
    IFEND;
    osp$pop_inhibit_job_recovery;

{Debug Code
    osp$disestablish_cond_handler;
    osp$decrement_locked_variable (nav$namve_tsk_hndl_active_count, 1, actual_value, ignore_error);
{End Debug Code

  PROCEND nap$gt_send_data_handler;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$gt_send_expedited_data', EJECT ??
*copy nah$gt_send_expedited_data

  PROCEDURE [XDCL, #GATE] nap$gt_send_expedited_data
    (    connection_id: nat$gt_connection_id,
         data: nat$data_fragments;
     VAR status: ost$status);

    VAR
      cl_connection: ^nlt$cl_connection,
      condition_cause: nat$gt_condition_cause;

?? NEWTITLE := 'terminate_send_expedited', EJECT ??

    PROCEDURE terminate_send_expedited
      (    condition: pmt$condition;
           ignore_condition_descriptor: ^pmt$condition_information;
           sa: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      nap$condition_handler_trace (condition, sa);
      CASE condition.selector OF
      = pmc$system_conditions =
        IF condition_cause = nac$gt_application_data THEN
          nlp$cl_release_exclusive_access (cl_connection);
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
          EXIT nap$gt_send_expedited_data;
        ELSE
          IF cl_connection <> NIL THEN
            nlp$cl_release_exclusive_access (cl_connection);
          IFEND;
          osp$pop_inhibit_job_recovery;
          osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
        IFEND;
      = pmc$user_defined_condition =
        IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
          pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        IFEND;
        condition_status.normal := TRUE;
      ELSE
        condition_status.normal := TRUE;
      CASEND;
    PROCEND terminate_send_expedited;
?? OLDTITLE, EJECT ??

    VAR
      connection: ^nat$gt_connection,
      data_length: nat$data_length,
      message_id: nlt$bm_message_id,
      internal_status: ost$status,
      local_status: ost$status;

    status.normal := TRUE;
    nlp$al_get_data_length (data, data_length);
    IF data_length <= nac$gt_maximum_expedited_data THEN
      osp$push_inhibit_job_recovery;
      cl_connection := NIL;
      osp$establish_condition_handler (^terminate_send_expedited, FALSE);
      condition_cause := nac$gt_request_not_cause;
      #SPOIL (condition_cause, cl_connection);
      get_connection_access (connection_id, cl_connection, connection, internal_status);
      IF internal_status.normal THEN
        IF connection^.state = nac$gt_open THEN
          condition_cause := nac$gt_application_data;
          #SPOIL (condition_cause);
          nlp$bm_create_message (data, message_id, internal_status);
          nlp$ta_send_expedited_data (cl_connection, message_id, internal_status);
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface,
                internal_status);
        IFEND;
        nlp$cl_release_exclusive_access (cl_connection);
        osp$pop_inhibit_job_recovery;
      IFEND;
      IF NOT internal_status.normal THEN
        osp$disestablish_cond_handler;
        status := internal_status;
      IFEND;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$max_data_length_exceeded, external_interface, status);
    IFEND;
  PROCEND nap$gt_send_expedited_data;
?? OLDTITLE ??
*if false
?? NEWTITLE := 'sap_open', EJECT ??

  FUNCTION sap_open
    (    sap_id: nat$gt_sap_identifier): boolean;

    VAR
      job_sap: ^nat$gt_job_sap;

    job_sap := nav$gt_job_sap_list.first_sap;
    WHILE (job_sap <> NIL) AND (job_sap^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      job_sap := job_sap^.next_sap;
    WHILEND;
    sap_open := job_sap <> NIL;
  FUNCEND sap_open;
?? OLDTITLE ??
*ifend
?? NEWTITLE := 'sap_priority', EJECT ??

  FUNCTION [INLINE] sap_priority
    (    sap_id: nat$gt_sap_identifier): nlt$ta_priority;

    VAR
      job_sap: ^nat$gt_job_sap;

    job_sap := nav$gt_job_sap_list.first_sap;
    WHILE (job_sap <> NIL) AND (job_sap^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      job_sap := job_sap^.next_sap;
    WHILEND;
    IF job_sap <> NIL THEN
      sap_priority := job_sap^.priority;
    ELSE
      sap_priority := 0;
    IFEND;

  FUNCEND sap_priority;
?? OLDTITLE ??
?? NEWTITLE := 'get_sap_access', EJECT ??

  PROCEDURE get_sap_access
    (    sap_id: nat$gt_sap_identifier;
     VAR sap: ^nat$gt_sap;
     VAR server_job: boolean;
     VAR status: ost$status);

    VAR
      ignore_sap_found: boolean,
      active_sap: ^^nat$gt_sap,
      job_sap: ^nat$gt_job_sap;

    status.normal := TRUE;
    nap$gt_get_exclusive_to_slist;
    job_sap := nav$gt_job_sap_list.first_sap;
    WHILE (job_sap <> NIL) AND (job_sap^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      job_sap := job_sap^.next_sap;
    WHILEND;
    IF job_sap <> NIL THEN
      server_job := job_sap^.shared_sap_server;
      osp$begin_subsystem_activity;
      osp$set_job_signature_lock (nav$gt_sap_list.lock);
      find_active_sap (job_sap^.selector, active_sap, ignore_sap_found);
      sap := active_sap^;
    ELSE
      nap$gt_releas_exclusiv_to_slist;
      osp$set_status_abnormal (nac$status_id, nae$sap_not_open, external_interface, status);
    IFEND;
  PROCEND get_sap_access;
?? OLDTITLE ??
?? NEWTITLE := 'get_server_sap_access', EJECT ??

  PROCEDURE [inline] get_server_sap_access
    (    sap_id: nat$gt_sap_identifier;
     VAR sap: ^nat$gt_sap;
     VAR status: ost$status);

    VAR
      ignore_sap_found: boolean,
      active_sap: ^^nat$gt_sap,
      job_sap: ^nat$gt_job_sap;

    status.normal := TRUE;
    nap$gt_get_exclusive_to_slist;
    job_sap := nav$gt_job_sap_list.first_sap;
    /search_for_server_job_sap/
    WHILE (job_sap <> NIL) DO
      IF (job_sap^.selector.osi_sap_identifier = sap_id.osi_sap_identifier) AND
            (job_sap^.shared_sap_server) THEN
        EXIT /search_for_server_job_sap/;
      IFEND;
      job_sap := job_sap^.next_sap;
    WHILEND /search_for_server_job_sap/;
    IF job_sap <> NIL THEN
      osp$begin_subsystem_activity;
      osp$set_job_signature_lock (nav$gt_sap_list.lock);
      find_active_sap (job_sap^.selector, active_sap, ignore_sap_found);
      sap := active_sap^;
    ELSE
      nap$gt_releas_exclusiv_to_slist;
      osp$set_status_abnormal (nac$status_id, nae$sap_not_open, external_interface, status);
    IFEND;
  PROCEND get_server_sap_access;
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] release_sap_access'??
?? NEWTITLE := '[INLINE] clear_sap_access', EJECT ??

  PROCEDURE [INLINE] release_sap_access;

    osp$clear_job_signature_lock (nav$gt_sap_list.lock);
    osp$end_subsystem_activity;
    nap$gt_releas_exclusiv_to_slist;
  PROCEND release_sap_access;


  PROCEDURE [INLINE] clear_sap_access;

    VAR
      lock_status: ost$signature_lock_status;

    osp$test_sig_lock (nav$gt_sap_list.lock, lock_status);
    IF lock_status = osc$sls_locked_by_current_task THEN
      osp$clear_job_signature_lock (nav$gt_sap_list.lock);
      osp$end_subsystem_activity;
    IFEND;
    nap$gt_clear_exclusive_to_slist;
  PROCEND clear_sap_access;
?? OLDTITLE ??
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] find_active_sap', EJECT ??

  PROCEDURE [INLINE] find_active_sap
    (    sap_id: nat$gt_sap_identifier;
     VAR active_sap: ^^nat$gt_sap;
     VAR sap_found: boolean);

    active_sap := ^nav$gt_sap_list.first_sap;
    WHILE (active_sap^ <> NIL) AND (active_sap^^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      active_sap := ^active_sap^^.next_sap;
    WHILEND;
    sap_found := active_sap^ <> NIL;
  PROCEND find_active_sap;
?? OLDTITLE ??
?? NEWTITLE := 'delete_connection_from_sap', EJECT ??

  PROCEDURE delete_connection_from_sap
    (    connection_id: nat$gt_connection_id;
         sap_id: nat$gt_sap_identifier);

    VAR
      active_sap: ^^nat$gt_sap,
      sap_connection: ^^nat$gt_sap_connection,
      connection_to_delete: ^nat$gt_sap_connection;

    osp$begin_subsystem_activity;
    osp$set_job_signature_lock (nav$gt_sap_list.lock);
    active_sap := ^nav$gt_sap_list.first_sap;
    WHILE (active_sap^ <> NIL) AND (active_sap^^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      active_sap := ^active_sap^^.next_sap;
    WHILEND;
    IF (active_sap^ <> NIL) THEN
      sap_connection := ^active_sap^^.first_connection;
      WHILE (sap_connection^ <> NIL) AND (sap_connection^^.connection_id <> connection_id) DO
        sap_connection := ^sap_connection^^.next_connection;
      WHILEND;
      IF sap_connection^ <> NIL THEN
        connection_to_delete := sap_connection^;
        sap_connection^ := sap_connection^^.next_connection;
        FREE connection_to_delete IN nav$network_paged_heap^;
      IFEND;
    IFEND;
    osp$clear_job_signature_lock (nav$gt_sap_list.lock);
    osp$end_subsystem_activity;
  PROCEND delete_connection_from_sap;
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] get_sap_to_delete', EJECT ??

  PROCEDURE [INLINE] get_sap_to_delete
    (    sap_id: nat$gt_sap_identifier;
     VAR sap_to_delete: ^nat$gt_job_sap;
     VAR status: ost$status);

    status.normal := TRUE;
    sap_to_delete := nav$gt_job_sap_list.first_sap;
    WHILE (sap_to_delete<>NIL) AND (sap_to_delete^.sap_id.osi_sap_identifier <> sap_id.osi_sap_identifier) DO
      sap_to_delete := sap_to_delete^.next_sap;
    WHILEND;
    IF sap_to_delete = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$sap_not_open, external_interface, status);
    IFEND;
  PROCEND get_sap_to_delete;
?? OLDTITLE ??
?? NEWTITLE := 'get_connection_to_delete', EJECT ??

  PROCEDURE get_connection_to_delete
    (    connection_id: nat$gt_connection_id;
     VAR connection_to_delete: ^nat$gt_job_connection;
     VAR cl_connection: ^nlt$cl_connection;
     VAR connection: ^nat$gt_connection;
     VAR status: ost$status);

    VAR
      job_connection: ^nat$gt_job_connection,
      connection_exists: boolean,
      layer_active: boolean,
      termination_condition: ost$status_condition;

    status.normal := TRUE;
    job_connection := nav$gt_job_connection_list.first_connection;
    WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
      job_connection := job_connection^.next_connection;
    WHILEND;
    IF ((job_connection <> NIL) AND job_connection^.active) THEN
      nlp$cl_get_exclusive_via_cid (job_connection^.active_connection_id, connection_exists, cl_connection);
      IF connection_exists THEN
        nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active,
              connection);
        IF layer_active THEN
          IF connection^.state IN $nat$gt_connection_states [nac$gt_peer_reject, nac$gt_peer_disconnect,
                nac$gt_connection_failed] THEN
            CASE connection^.state OF
            = nac$gt_peer_disconnect =
              nlp$bm_release_message (connection^.event_queue.beginning^.event.osi_disconnect.data);
              termination_condition := nae$conn_terminated_by_peer;
            = nac$gt_connection_failed =
              termination_condition := nae$connection_failed;
            ELSE
            CASEND;
            FREE connection^.event_queue.beginning IN nav$network_paged_heap^;
            nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
            nlp$cl_release_exclusive_access (cl_connection);
            delete_connection_from_sap (connection_id, job_connection^.sap_id);
            nap$gt_delete_job_connection (connection_id);
            osp$set_status_abnormal (nac$status_id, termination_condition, external_interface, status);
          ELSE
            connection_to_delete := job_connection;
          IFEND;
        ELSE
          nlp$cl_release_exclusive_access (cl_connection);
          delete_connection_from_sap (connection_id, job_connection^.sap_id);
          nap$gt_delete_job_connection (connection_id);
          osp$set_status_abnormal (nac$status_id, nae$connection_failed, external_interface, status);
        IFEND;
      ELSE
        delete_connection_from_sap (connection_id, job_connection^.sap_id);
        nap$gt_delete_job_connection (connection_id);
        osp$set_status_abnormal (nac$status_id, nae$connection_failed, external_interface, status);
      IFEND;
    ELSEIF job_connection <> NIL THEN
      CASE job_connection^.termination_state OF
      = nac$gt_peer_disconnect =
        termination_condition := nae$conn_terminated_by_peer;
      = nac$gt_connection_failed =
        termination_condition := nae$connection_failed;
      ELSE
      CASEND;
      delete_connection_from_sap (connection_id, job_connection^.sap_id);
      nap$gt_delete_job_connection (connection_id);
      osp$set_status_abnormal (nac$status_id, termination_condition, external_interface, status);
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface, status);
    IFEND;
  PROCEND get_connection_to_delete;
?? OLDTITLE ??
?? NEWTITLE := 'get_connection_access', EJECT ??

  PROCEDURE get_connection_access
    (    connection_id: nat$gt_connection_id;
     VAR cl_connection: ^nlt$cl_connection;
     VAR connection: ^nat$gt_connection;
     VAR status: ost$status);

    VAR
      job_connection: ^nat$gt_job_connection,
      connection_exists: boolean,
      layer_active: boolean,
      termination_condition: ost$status_condition;

    status.normal := TRUE;
    nap$gt_get_exclusive_to_clist;
    job_connection := nav$gt_job_connection_list.first_connection;
    WHILE (job_connection <> NIL) AND (job_connection^.connection_id <> connection_id) DO
      job_connection := job_connection^.next_connection;
    WHILEND;
    IF ((job_connection <> NIL) AND job_connection^.active) THEN
      nlp$cl_get_exclusive_via_cid (job_connection^.active_connection_id, connection_exists, cl_connection);
      IF connection_exists THEN
        nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active,
              connection);
        IF layer_active THEN
          IF connection^.state IN $nat$gt_connection_states [nac$gt_peer_reject, nac$gt_peer_disconnect,
                nac$gt_connection_failed] THEN
            nap$gt_deactivate_job_connect (connection^.state, connection^.event_queue.beginning^.event,
                  connection^.event_queue.beginning^.data_length, job_connection);
            CASE connection^.state OF
            = nac$gt_peer_reject, nac$gt_peer_disconnect =
              termination_condition := nae$conn_terminated_by_peer;
            = nac$gt_connection_failed =
              termination_condition := nae$connection_failed;
            CASEND;
            FREE connection^.event_queue.beginning IN nav$network_paged_heap^;
            connection^.state := nac$gt_closed;
            nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
            nlp$cl_release_exclusive_access (cl_connection);
            osp$set_status_abnormal (nac$status_id, termination_condition, external_interface, status);
          IFEND;
        ELSE
          nlp$cl_release_exclusive_access (cl_connection);
          delete_connection_from_sap (connection_id, job_connection^.sap_id);
          nap$gt_delete_job_connection (connection_id);
          osp$set_status_abnormal (nac$status_id, nae$connection_failed, external_interface, status);
        IFEND;
      ELSE
        delete_connection_from_sap (connection_id, job_connection^.sap_id);
        nap$gt_delete_job_connection (connection_id);
        osp$set_status_abnormal (nac$status_id, nae$connection_failed, external_interface, status);
      IFEND;
    ELSEIF job_connection <> NIL THEN
      CASE job_connection^.termination_state OF
      = nac$gt_peer_reject, nac$gt_peer_disconnect =
        termination_condition := nae$conn_terminated_by_peer;
      = nac$gt_connection_failed =
        termination_condition := nae$connection_failed;
      CASEND;
      osp$set_status_abnormal (nac$status_id, termination_condition, external_interface, status);
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$connection_not_open, external_interface, status);
    IFEND;
    nap$gt_releas_exclusiv_to_clist;
  PROCEND get_connection_access;
?? OLDTITLE ??
?? NEWTITLE := 'delete_queued_events', EJECT ??

  PROCEDURE delete_queued_events
    (    connection: ^nat$gt_connection);

    VAR
      event_queue: ^^nat$gt_event_element,
      event_element: ^nat$gt_event_element,
      message_id: nlt$bm_message_id;

    event_queue := ^connection^.event_queue.beginning;
    WHILE event_queue^ <> NIL DO
      CASE event_queue^^.event.kind OF
      = nlc$ta_connect_confirm_event =
        message_id := event_queue^^.event.osi_connect_confirm.data;
        nlp$bm_release_message (message_id);
      = nlc$ta_data_event =
        message_id := event_queue^^.event.osi_data.data;
        nlp$bm_release_message (message_id);
      = nlc$ta_expedited_data_event =
        message_id := event_queue^^.event.osi_expedited_data.data;
        nlp$bm_release_message (message_id);
      = nlc$ta_disconnect_event =
        IF event_queue^^.event.osi_disconnect.proprietary_reason = nlc$ta_user_disconnect_request THEN
          message_id := event_queue^^.event.osi_disconnect.data;
          nlp$bm_release_message (message_id);
        IFEND;
      CASEND;
      event_element := event_queue^;
      event_queue^ := event_queue^^.next_event;
      FREE event_element IN nav$network_paged_heap^;
    WHILEND;
    connection^.undelivered_message_buffers := 0;
    connection^.event_queue.ending := NIL;
  PROCEND delete_queued_events;
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] activate_sender_task', EJECT ??

  PROCEDURE [INLINE] activate_sender_task
    (    cl_connection: ^nlt$cl_connection);

    VAR
      cl_connection_id: ^nlt$cl_connection_id,
      signal: pmt$signal,
      status: ost$status;

    signal.identifier := nac$gt_send_data;
    cl_connection_id := #LOC (signal.contents);
    cl_connection_id^ := cl_connection^.identifier;
    pmp$send_signal (cl_connection^.message_sender.task, signal, status);
    IF NOT status.normal THEN
      nlp$cl_deactivate_sender (cl_connection);
    IFEND;
  PROCEND activate_sender_task;
?? OLDTITLE ??
?? NEWTITLE := '[INLINE] activate_receiver_task', EJECT ??

  PROCEDURE [INLINE] activate_receiver_task
    (    cl_connection: ^nlt$cl_connection);

    VAR
      cl_connection_id: ^nlt$cl_connection_id,
      signal: pmt$signal,
      status: ost$status;

    signal.identifier := nac$gt_deliver_data;
    cl_connection_id := #LOC (signal.contents);
    cl_connection_id^ := cl_connection^.identifier;
    pmp$send_signal (cl_connection^.message_receiver.task, signal, status);
    IF NOT status.normal THEN
      nlp$cl_deactivate_receiver (cl_connection);
    IFEND;
  PROCEND activate_receiver_task;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_process_connection_event'??
?? NEWTITLE := 'continue_send_data'??
?? NEWTITLE := 'terminate_send', EJECT ??

  PROCEDURE [XDCL] nap$gt_process_connection_event
    (    cl_connection: ^nlt$cl_connection;
         event: nlt$ta_event;
     VAR inventory_report: nlt$ta_inventory_report);

    VAR
      status: ost$status;

    PROCEDURE continue_send_data
      (    connection: ^nat$gt_connection;
           cl_connection: ^nlt$cl_connection);

      VAR
        processing_task: ost$global_task_id,
        condition_cause: nat$gt_condition_cause;

      PROCEDURE terminate_send
        (    condition: pmt$condition;
             ignore_condition_descriptor: ^pmt$condition_information;
             sa: ^ost$stack_frame_save_area;
         VAR condition_status: ost$status);

        VAR
          activity_status: ^ost$activity_status,
          status: ost$status;

        nap$condition_handler_trace (condition, sa);
        CASE condition.selector OF
        = pmc$system_conditions, mmc$segment_access_condition =
          IF condition_cause = nac$gt_application_data THEN
            activity_status := connection^.sender_request.activity_status;
            nlp$cl_deactivate_sender (cl_connection);
            IF ((connection^.sender_request.application_buffer.description_kind = nac$gt_allocated) AND
                  (connection^.sender_request.application_buffer.allocated_description <> NIL)) THEN
              FREE connection^.sender_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            IFEND;
            connection^.sender_request := nav$gt_null_sender_request;
            osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
            osp$establish_condition_handler (^terminate_send, FALSE);
            condition_cause := nac$gt_activity_status;
            #SPOIL (condition_cause);
            activity_status^.complete := TRUE;
            activity_status^.status := status;
            EXIT continue_send_data;
          ELSEIF condition_cause = nac$gt_activity_status THEN
            IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task =
                  processing_task) THEN
              nlp$cl_deactivate_receiver (cl_connection);
              connection^.receiver_request := nav$gt_null_receiver_request;
            IFEND;
            IF cl_connection^.message_sender.active AND (cl_connection^.message_sender.task = processing_task)
                  THEN
              nlp$cl_deactivate_sender (cl_connection);
              connection^.sender_request := nav$gt_null_sender_request;
            IFEND;
            osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
          ELSE
            osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
          IFEND;
        = pmc$user_defined_condition =
          IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
            pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
          IFEND;
          condition_status.normal := TRUE;
        ELSE
          condition_status.normal := TRUE;
        CASEND;
      PROCEND terminate_send;
?? OLDTITLE, EJECT ??

      VAR
        capacity: nat$data_length;

      pmp$get_executing_task_gtid (processing_task);
      IF cl_connection^.message_sender.active AND (cl_connection^.message_sender.task = processing_task) THEN
        nlp$osi_get_outbound_capacity (cl_connection, capacity);
        IF (capacity > 0) THEN
          osp$establish_condition_handler (^terminate_send, FALSE);
          condition_cause := nac$gt_application_data;
          #SPOIL (condition_cause);
          WHILE (capacity > 0) AND (connection^.sender_request.remaining_bytes_to_send > 0) DO
            send_data (cl_connection, connection, capacity);
            nlp$osi_get_outbound_capacity (cl_connection, capacity);
          WHILEND;
          condition_cause := nac$gt_activity_status;
          #SPOIL (condition_cause);
          connection^.sender_request.activity_status^.complete :=
                connection^.sender_request.remaining_bytes_to_send = 0;
        IFEND;
      ELSEIF cl_connection^.message_sender.active THEN
        activate_sender_task (cl_connection);
      IFEND;
    PROCEND continue_send_data;
?? OLDTITLE ??
?? NEWTITLE := 'reassemble_data'??
?? NEWTITLE := 'terminate_reassemble_data', EJECT ??

    PROCEDURE reassemble_data
      (VAR event {INPUT} : nlt$ta_event;
           connection: ^nat$gt_connection;
           cl_connection: ^nlt$cl_connection);

      VAR
        processing_task: ost$global_task_id,
        condition_cause: nat$gt_condition_cause;


      PROCEDURE terminate_reassemble_data
        (    condition: pmt$condition;
             ignore_condition_descriptor: ^pmt$condition_information;
             sa: ^ost$stack_frame_save_area;
         VAR condition_status: ost$status);

        nap$condition_handler_trace (condition, sa);
        CASE condition.selector OF
        = pmc$system_conditions, mmc$segment_access_condition =
          IF condition_cause = nac$gt_application_data THEN
            nlp$cl_deactivate_receiver (cl_connection);
            IF ((connection^.receiver_request.application_buffer.description_kind = nac$gt_allocated) AND
                  (connection^.receiver_request.application_buffer.allocated_description <> NIL)) THEN
              FREE connection^.receiver_request.application_buffer.allocated_description IN
                    nav$network_paged_heap^;
            IFEND;
            connection^.receiver_request := nav$gt_null_receiver_request;
            osp$set_status_from_condition (nac$status_id, condition, sa, status, condition_status);
            osp$establish_condition_handler (^terminate_reassemble_data, FALSE);
            condition_cause := nac$gt_activity_status;
            #SPOIL (condition_cause);
            activity_status^.complete := TRUE;
            activity_status^.status := status;
            EXIT reassemble_data;
          ELSEIF condition_cause = nac$gt_activity_status THEN
            IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task =
                  processing_task) THEN
              nlp$cl_deactivate_receiver (cl_connection);
              connection^.receiver_request := nav$gt_null_receiver_request;
            IFEND;
            IF cl_connection^.message_sender.active AND (cl_connection^.message_sender.task = processing_task)
                  THEN
              nlp$cl_deactivate_sender (cl_connection);
              connection^.sender_request := nav$gt_null_sender_request;
            IFEND;
            nlp$ta_report_undelivered_data (cl_connection, connection^.undelivered_message_buffers);
            osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
          ELSE
            osp$set_status_from_condition (nac$status_id, condition, sa, condition_status, status);
          IFEND;
        = pmc$user_defined_condition =
          IF condition.user_condition_name = 'OSC$JOB_RECOVERY' THEN
            pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
          IFEND;
          condition_status.normal := TRUE;
        ELSE
          condition_status.normal := TRUE;
        CASEND;
      PROCEND terminate_reassemble_data;
?? OLDTITLE, EJECT ??

      VAR
        event_element: ^nat$gt_event_element,
        data_length: integer,
        number_of_buffers: integer,
        component_list: array [1 .. 2] of nlt$bm_message_id,
        delivery_complete: boolean,
        activity_status: ^ost$activity_status;

      nlp$bm_get_message_resources (event.osi_data.data, data_length, number_of_buffers);
      connection^.undelivered_message_buffers := connection^.undelivered_message_buffers + number_of_buffers;
      IF connection^.event_queue.ending <> NIL THEN
        IF ((connection^.event_queue.ending^.event.kind = nlc$ta_data_event) AND
              NOT connection^.event_queue.ending^.event.osi_data.end_of_message) THEN
          component_list [1] := connection^.event_queue.ending^.event.osi_data.data;
          component_list [2] := event.osi_data.data;
          nlp$bm_concatenate_messages (component_list, connection^.event_queue.ending^.event.osi_data.data);
          connection^.event_queue.ending^.data_length := connection^.event_queue.ending^.data_length +
                data_length;
          connection^.event_queue.ending^.event.osi_data.end_of_message := event.osi_data.end_of_message;
        ELSE
          REPEAT
            ALLOCATE event_element IN nav$network_paged_heap^;
            IF event_element = NIL THEN
              syp$cycle;
            IFEND;
          UNTIL event_element <> NIL;
          event_element^.data_length := data_length;
          event_element^.event := event;
          event_element^.next_event := NIL;
          connection^.event_queue.ending^.next_event := event_element;
          connection^.event_queue.ending := event_element;
        IFEND;
      ELSE
        REPEAT
          ALLOCATE event_element IN nav$network_paged_heap^;
          IF event_element = NIL THEN
            syp$cycle;
          IFEND;
        UNTIL event_element <> NIL;
        event_element^.data_length := data_length;
        event_element^.event := event;
        event_element^.next_event := NIL;
        connection^.event_queue.beginning := event_element;
        connection^.event_queue.ending := event_element;
        nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
      IFEND;
      pmp$get_executing_task_gtid (processing_task);
      IF cl_connection^.message_receiver.active AND (cl_connection^.message_receiver.task = processing_task)
            THEN
        osp$establish_condition_handler (^terminate_reassemble_data, FALSE);
        condition_cause := nac$gt_application_data;
        #SPOIL (condition_cause);
        deliver_connection_events (connection, cl_connection, delivery_complete);
        IF delivery_complete THEN
          nlp$cl_deactivate_receiver (cl_connection);
          activity_status := connection^.receiver_request.activity_status;
          connection^.receiver_request := nav$gt_null_receiver_request;
          condition_cause := nac$gt_activity_status;
          #SPOIL (condition_cause);
          activity_status^.complete := TRUE;
        IFEND;
      ELSEIF cl_connection^.message_receiver.active THEN
        activate_receiver_task (cl_connection);
      IFEND;
    PROCEND reassemble_data;
?? OLDTITLE ??
?? NEWTITLE := 'queue_event', EJECT ??

    PROCEDURE queue_event
      (VAR event {INPUT} : nlt$ta_event;
           connection: ^nat$gt_connection;
           cl_connection: ^nlt$cl_connection);

      VAR
        event_element: ^nat$gt_event_element;

      CASE event.kind OF
      = nlc$ta_expedited_data_event =
        REPEAT
          ALLOCATE event_element IN nav$network_paged_heap^;
          IF event_element = NIL THEN
            syp$cycle;
          IFEND;
        UNTIL event_element <> NIL;
        event_element^.event := event;
        event_element^.next_event := NIL;
        nlp$bm_get_message_length (event.osi_expedited_data.data, event_element^.data_length);
        IF connection^.event_queue.beginning = NIL THEN
          connection^.event_queue.beginning := event_element;
          connection^.event_queue.ending := event_element;
          nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
          IF cl_connection^.message_receiver.active THEN
            activate_receiver_task (cl_connection);
          IFEND;
        ELSE
          connection^.event_queue.ending^.next_event := event_element;
          connection^.event_queue.ending := event_element;
        IFEND;

      = nlc$ta_disconnect_event =
        delete_queued_events (connection);
        IF connection^.state <> nac$gt_connect_request_received THEN
          REPEAT
            ALLOCATE event_element IN nav$network_paged_heap^;
            IF event_element = NIL THEN
              syp$cycle;
            IFEND;
          UNTIL event_element <> NIL;
          event_element^.event := event;
          event_element^.next_event := NIL;
          connection^.event_queue.beginning := event_element;
          connection^.event_queue.ending := event_element;
          IF event.osi_disconnect.proprietary_reason = nlc$ta_user_disconnect_request THEN
            nlp$bm_get_message_length (event.osi_disconnect.data, event_element^.data_length);
            connection^.state := nac$gt_peer_disconnect;
          ELSE
            event_element^.data_length := 0;
            connection^.state := nac$gt_connection_failed;
          IFEND;
          nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
          IF cl_connection^.message_receiver.active THEN
            activate_receiver_task (cl_connection);
          IFEND;
        ELSE { Application has not received connect request -- terminate connection. }
          nlp$bm_release_message (event.osi_disconnect.data);
          connection^.state := nac$gt_closed;
          nlp$cl_deactivate_layer (nlc$osi_generic_xport_interface, cl_connection);
        IFEND;

      = nlc$ta_connect_confirm_event =
        REPEAT
          ALLOCATE event_element IN nav$network_paged_heap^;
          IF event_element = NIL THEN
            syp$cycle;
          IFEND;
        UNTIL event_element <> NIL;
        event_element^.event := event;
        event_element^.next_event := NIL;
        connection^.event_queue.beginning := event_element;
        connection^.event_queue.ending := event_element;
        nlp$bm_get_message_length (event_element^.event.osi_connect_confirm.data, event_element^.data_length);
        connection^.state := nac$gt_accept_received;
        nlp$select_timer (nac$gt_event_timer_duration, 0, connection^.timer);
        IF cl_connection^.message_receiver.active THEN
          activate_receiver_task (cl_connection);
        IFEND;
      ELSE
      CASEND;
    PROCEND queue_event;
?? OLDTITLE, EJECT ??

    VAR
      layer_active: boolean,
      connection: ^nat$gt_connection,
      connection_event: nlt$ta_event;

    nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active, connection);
    IF event.kind = nlc$ta_data_event THEN
      connection_event := event;
      reassemble_data (connection_event, connection, cl_connection);
      inventory_report.changed := TRUE;
      inventory_report.accumulated_message_buffers := connection^.undelivered_message_buffers;
    ELSEIF event.kind = nlc$ta_clear_to_send_event THEN
      continue_send_data (connection, cl_connection);
      inventory_report.changed := FALSE;
    ELSE
      connection_event := event;
      queue_event (connection_event, connection, cl_connection);
      inventory_report.changed := FALSE;
    IFEND;
  PROCEND nap$gt_process_connection_event;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_process_sap_event', EJECT ??

  PROCEDURE [XDCL] nap$gt_process_sap_event
    (    cl_connection: ^nlt$cl_connection;
         event: nlt$ta_event;
     VAR inventory_report: nlt$ta_inventory_report);

    VAR
      connect_request: ^nat$gt_connect_request,
      connection: ^nat$gt_connection,
      layer_active: boolean,
      message_id: nlt$bm_message_id,
      sap: ^nat$gt_sap,
      sap_id: ^nat$gt_sap_identifier,
      signal: pmt$signal,
      status: ost$status;

    inventory_report.changed := FALSE;
    osp$begin_subsystem_activity;
    osp$set_job_signature_lock (nav$gt_sap_list.lock);
    sap := nav$gt_sap_list.first_sap;
    WHILE (sap <> NIL) AND (sap^.sap_id.osi_sap_identifier <> event.osi_connect.destination_transport_sap) DO
      sap := sap^.next_sap;
    WHILEND;
    IF (sap <> NIL) AND
          ((NOT sap^.opened_via_share) OR ((sap^.opened_via_share) AND (sap^.shared_sap_server_active))) THEN
      nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active, connection);
      ALLOCATE connect_request IN nav$network_paged_heap^;
      IF connect_request <> NIL THEN
        connection^ := nav$gt_null_connection;
        connection^.state := nac$gt_connect_request_received;
        connection^.sap_id := sap^.sap_id;
        nlp$cl_activate_layer (cl_connection^.application_layer, cl_connection);
        connect_request^.next_connect_request := NIL;
        connect_request^.connection_id := cl_connection^.identifier;
        nlp$bm_get_message_length (event.osi_connect.data, connect_request^.data_length);
        connect_request^.data := event.osi_connect.data;
        connect_request^.source.kind := osi;
        connect_request^.source.osi_address := event.osi_connect.source_address;
        connect_request^.checksum := event.osi_connect.checksum;
        connect_request^.expedited_data := event.osi_connect.expedited_data;
        IF sap^.connect_request_queue.beginning = NIL THEN
          sap^.connect_request_queue.beginning := connect_request;
          sap^.connect_request_queue.ending := connect_request;
          nlp$select_timer (nac$gt_sap_event_timer_duration, 0, sap^.event_timer);
          IF sap^.connect_request_receiver.active THEN
            signal.identifier := nac$gt_deliver_connect_request;
            sap_id := #LOC (signal.contents);
            sap_id^ := sap^.sap_id;
            pmp$send_signal (sap^.connect_request_receiver.task, signal, {ignore} status);
          IFEND;
        ELSE
          sap^.connect_request_queue.ending^.next_connect_request := connect_request;
          sap^.connect_request_queue.ending := connect_request;
        IFEND;
      ELSE
        message_id := event.osi_connect.data;
        nlp$ta_disconnect_connection (cl_connection, message_id, status);
      IFEND;
      osp$clear_job_signature_lock (nav$gt_sap_list.lock);
      osp$end_subsystem_activity;
    ELSE
      message_id := event.osi_connect.data;
      nlp$ta_disconnect_connection (cl_connection, message_id, status);
      osp$clear_job_signature_lock (nav$gt_sap_list.lock);
      osp$end_subsystem_activity;
    IFEND;
  PROCEND nap$gt_process_sap_event;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_evaluate_connect_timers', EJECT ??

  PROCEDURE [XDCL] nap$gt_evaluate_connect_timers
    (    current_time: integer;
         cl_connection: ^nlt$cl_connection);

    VAR
      layer_active: boolean,
      connection: ^nat$gt_connection,
      empty_message: nlt$bm_message_id,
      ignore_status: ost$status;

    nlp$cl_get_layer_connection (cl_connection^.application_layer, cl_connection, layer_active, connection);
    IF layer_active THEN
      IF nlp$timer_expired (current_time, connection^.timer) THEN
        delete_queued_events (connection);
        nlp$bm_create_message (nav$gt_null_message, empty_message, ignore_status);
        nlp$ta_disconnect_connection (cl_connection, empty_message, ignore_status);
        connection^.state := nac$gt_closed;
        nlp$cl_deactivate_layer (cl_connection^.application_layer, cl_connection);
      IFEND;
    IFEND;
  PROCEND nap$gt_evaluate_connect_timers;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$gt_evaluate_sap_timers', EJECT ??

  PROCEDURE [XDCL] nap$gt_evaluate_sap_timers
    (    current_time: integer);

    VAR
      sap: ^nat$gt_sap,
      connect_request: ^nat$gt_connect_request;

    osp$begin_subsystem_activity;
    osp$set_job_signature_lock (nav$gt_sap_list.lock);
    sap := nav$gt_sap_list.first_sap;
    WHILE (sap <> NIL) DO
      IF nlp$timer_expired (current_time, sap^.event_timer) THEN
        IF sap^.connect_request_queue.beginning <> NIL THEN
          connect_request := sap^.connect_request_queue.beginning;
          sap^.connect_request_queue.beginning := connect_request^.next_connect_request;
          IF sap^.connect_request_queue.beginning = NIL THEN
            sap^.connect_request_queue.ending := NIL;
          IFEND;
          reject_connection (connect_request^.connection_id, connect_request^.data);
          FREE connect_request IN nav$network_paged_heap^;
          nlp$select_timer (nac$gt_sap_event_timer_duration, 0, sap^.event_timer)
        ELSE
          nlp$cancel_timer (sap^.event_timer)
        IFEND;
      IFEND;
      sap := sap^.next_sap;
    WHILEND;
    osp$clear_job_signature_lock (nav$gt_sap_list.lock);
    osp$end_subsystem_activity;
  PROCEND nap$gt_evaluate_sap_timers;
?? OLDTITLE ??
MODEND nam$external_gt_interface;
