?? RIGHT := 110 ??
?? NEWTITLE := 'NAM$APPLICATION_MANAGEMENT' ??
MODULE nam$application_management;
?? RIGHT := 110 ??
?? PUSH (LISTEXT := ON) ??
*copyc amt$file_attributes
*copyc clt$file
*copyc fst$path
*copyc jmt$system_supplied_name
*copyc mmt$access_selections
*copyc nac$application_catalog_layout
*copyc nae$application_interfaces
*copyc nae$application_management
*copyc nae$directory_me_conditions
*copyc nae$manage_network_applications
*copyc nae$namve_conditions
*copyc nat$application_name
*copyc nat$application_status
*copyc nat$application_type
*copyc nat$connection_id
*copyc nat$create_attributes
*copyc nat$directory_interfaces
*copyc nat$directory_priority
*copyc nat$directory_search_identifier
*copyc nat$protocol
*copyc nat$number_of_connections
*copyc nat$network_address
*copyc nat$termination_reason
*copyc nat$title
*copyc nat$title_attributes
*copyc nat$title_pattern
*copyc nat$title_pattern_list
*copyc nat$translation_attributes
*copyc nat$wait_time
*copyc nlc$ta_sap_ranges
*copyc osc$timesharing
*copyc ost$processor_model_number
*copyc ost$status_message
*copyc pmt$condition
*copyc pmt$condition_handler
*copyc pmt$program_parameters
?? POP ??
*copyc nat$application_file_definition
*copyc nat$client_attributes
*copyc nat$server_attributes
*copyc nat$tcpip_address
*copyc nat$tcpip_attributes
*copyc nat$tcp_socket
*copyc nat$udp_socket
?? TITLE := 'XREF PROCEDURES', EJECT ??
*copyc amp$get_segment_pointer
*copyc amp$put_next
*copyc amp$return
*copyc amp$set_segment_eoi
*copyc avp$get_capability
*copyc baf$task_file_entry_p
*copyc clp$convert_string_to_file
*copyc fsp$close_file
*copyc fsp$copy_file
*copyc fsp$open_file
*copyc i#move
*copyc jmp$generate_timesharing_title
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc nap$condition_handler_trace
*copyc nap$display_message
*copyc nap$gt_process_job_termination
*copyc nap$namve_system_error
*copyc nap$se_terminate_connection
*copyc nap$sk_process_job_termination
*copyc nlp$delete_registered_title
*copyc nlp$name_match
*copyc nlp$se_close_sap
*copyc nlp$se_open_sap
*copyc nlp$sk_tcp_terminate_all_listen
*copyc nlp$sk_tcp_terminate_socket
*copyc nlp$register_title
*copyc nlp$udp_close_socket
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$clear_job_signature_lock
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$format_message
*copyc osp$pop_inhibit_job_recovery
*copyc osp$push_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 pfp$attach
*copyc pfp$begin_system_authority
*copyc pfp$change
*copyc pfp$convert_pft$path_to_fs_path
*copyc pfp$define
*copyc pfp$define_catalog
*copyc pfp$end_system_authority
*copyc pfp$find_cycle_array
*copyc pfp$find_cycle_entry
*copyc pfp$find_directory_array
*copyc pfp$find_direct_info_record
*copyc pfp$find_next_info_record
*copyc pfp$get_item_info
*copyc pfp$purge
*copyc pmp$get_compact_date_time
*copyc pmp$get_job_names
*copyc pmp$get_pseudo_mainframe_id
*copyc pmp$get_unique_name
{***DEBUG   *copyc pmp$log
*copyc pmp$ready_task
*copyc rmp$get_device_class
?? TITLE := 'GLOBAL VARIABLES', EJECT ??
*copyc oss$job_paged_literal
*copyc osv$task_private_heap
*copyc nav$assigned_sap_list
*copyc nav$network_paged_heap
*copyc nav$namve_active
*copyc nav$applications_installed
*copyc nav$appl_defn_time_stamp
*copyc nav$client_attributes_list
*copyc nav$server_attributes_list
*copyc nav$tcpip_attributes_list

  CONST
    minimum_xns_sap_identifier = 2000;

  VAR
    access_selections: [READ, oss$job_paged_literal] array
          [1 .. 1] of fst$attachment_option := [[fsc$access_and_share_modes,
          [fsc$specific_access_modes, [fsc$read, fsc$modify, fsc$append]],
          [fsc$determine_from_access_modes]]],
    activate_client#: [READ, oss$job_paged_literal] string (15) := 'ACTIVATE_CLIENT',
    activate_server#: [READ, oss$job_paged_literal] string (15) := 'ACTIVATE_SERVER',
    activate_tcpip#: [READ, oss$job_paged_literal] string (14) := 'ACTIVATE_TCPIP',
    add_server_title: [READ, oss$job_paged_literal] string (20) := 'NAP$ADD_SERVER_TITLE',
    appl_mgmt_capability_verified: boolean := FALSE,
    application_catalog: [READ, oss$job_paged_literal] array [1 .. 4] of
          pft$name := [nac$application_family, nac$application_master_catalog, nac$network_subcatalog,
          nac$application_catalog],
    application_file_path: [READ, oss$job_paged_literal] array [1 .. 5] of
          pft$name := [nac$application_family, nac$application_master_catalog, nac$network_subcatalog,
          nac$application_catalog, nac$application_file],
    application_job_catalog: [READ, oss$job_paged_literal] array [1 .. 5] of
          pft$name := [nac$application_family, nac$application_master_catalog, nac$network_subcatalog,
          nac$application_catalog, nac$application_job_catalog],
    application_job_file_path: [READ, STATIC, oss$job_paged_literal] array [1 .. 6] of
          pft$name := [nac$application_family, nac$application_master_catalog, nac$network_subcatalog,
          nac$application_catalog, nac$application_job_catalog, * ],
    attach_application_file: [READ, oss$job_paged_literal] string (23) := 'ATTACH_APPLICATION_FILE',
    attributes_parameter: [READ, oss$job_paged_literal] string (10) := 'ATTRIBUTES',
    change_client: [READ, oss$job_paged_literal] string (13) := 'CHANGE_CLIENT',
    change_server: [READ, oss$job_paged_literal] string (13) := 'CHANGE_SERVER',
    change_tcpip: [READ, oss$job_paged_literal] string (12) := 'CHANGE_TCPIP',
    client: [READ, oss$job_paged_literal] string (6) := 'CLIENT',
    cycle_1: [READ, oss$job_paged_literal] pft$cycle_selector :=
          [pfc$specific_cycle, pfc$minimum_cycle_number],
    cycle_1_purged: [READ, oss$job_paged_literal] string (47) :=
          'Cycle 1 of application definitions file purged.',
    cycle_2: [READ, oss$job_paged_literal] pft$cycle_selector :=
          [pfc$specific_cycle, pfc$minimum_cycle_number + 1],
    deactivate_client#: [READ, oss$job_paged_literal] string (17) := 'DEACTIVATE_CLIENT',
    deactivate_server#: [READ, oss$job_paged_literal] string (17) := 'DEACTIVATE_SERVER',
    deactivate_tcpip#: [READ, oss$job_paged_literal] string (16) := 'DEACTIVATE_TCPIP',
    default_directory_password: [READ, oss$job_paged_literal] nat$directory_password := 0,
    default_password: [READ, oss$job_paged_literal] pft$password := '',
    define_client: [READ, oss$job_paged_literal] string (13) := 'DEFINE_CLIENT',
    define_server: [READ, oss$job_paged_literal] string (13) := 'DEFINE_SERVER',
    define_tcpip: [READ, oss$job_paged_literal] string (12) := 'DEFINE_TCPIP',
    delete_client: [READ, oss$job_paged_literal] string (13) := 'DELETE_CLIENT',
    delete_server: [READ, oss$job_paged_literal] string (13) := 'DELETE_SERVER',
    delete_tcpip: [READ, oss$job_paged_literal] string (12) := 'DELETE_TCPIP',
    delete_server_title: [READ, oss$job_paged_literal] string (23) := 'NAP$DELETE_SERVER_TITLE',
    highest_cycle: [READ, oss$job_paged_literal] pft$cycle_selector := [pfc$highest_cycle],
    highest_cycle_id: amt$file_identifier,
    highest_cycle_open: boolean := FALSE,
    initialize_access_control: [READ, oss$job_paged_literal] nlt$access_control := [FALSE, 0, FALSE, 0],
    job_file_access_selections: [READ, oss$job_paged_literal] array
          [1 .. 2] of fst$attachment_option := [[fsc$create_file, FALSE],
          [fsc$access_and_share_modes, [fsc$specific_access_modes, [fsc$read]],
          [fsc$specific_share_modes, [fsc$read, fsc$execute]]]],
    manage_network_applications: [READ, oss$job_paged_literal] string (35) :=
          'MANAGE_NETWORK_APPLICATIONS UTILITY',
    old_application_file: ^SEQ ( * ),
    server: [READ, oss$job_paged_literal] string (6) := 'SERVER',
    tcpip: [READ, oss$job_paged_literal] string (5) := 'TCPIP',
    verify_application_id: [READ, oss$job_paged_literal] string (25) := 'NAP$VERIFY_APPLICATION_ID';

?? TITLE := 'activate_client', EJECT ??

  PROCEDURE activate_client
    (    client_attributes: ^nat$client_attributes;
     VAR status: ost$status);

{ The client attributes list has to be locked by the caller.

    status.normal := TRUE;
    IF NOT client_attributes^.sap_open THEN
      assign_sap_identifier (client_attributes^.reserved_application_id,
            client_attributes^.application_id.osi_sap_identifier, status);
      IF status.normal THEN
        nlp$se_open_sap (nac$nil, FALSE, client_attributes^.max_connections, status);
        IF status.normal THEN
          client_attributes^.sap_open := TRUE;
        ELSE
          unassign_sap_identifier (client_attributes^.application_id.osi_sap_identifier);
        IFEND;
      IFEND;
    IFEND;

  PROCEND activate_client;
?? TITLE := 'activate_server', EJECT ??

  PROCEDURE activate_server
    (    server_attributes: ^nat$server_attributes;
     VAR status: ost$status);

    VAR
      domain: nat$title_domain,
      i: integer,
      protocol: nat$protocol,
      server_title: ^nat$server_title,
      osi_address: nat$osi_registration_address,
      user_identifier: ost$name;

{ The server attributes list has to be locked by the caller.

    IF NOT server_attributes^.sap_open THEN
      assign_sap_identifier (server_attributes^.reserved_application_id,
            server_attributes^.application_id.osi_sap_identifier, status);
      IF status.normal THEN
        nlp$se_open_sap (nac$monitor_server_connections, TRUE, server_attributes^.max_connections, status);
        IF status.normal THEN
          server_attributes^.sap_open := TRUE;
        ELSE
          unassign_sap_identifier (server_attributes^.application_id.osi_sap_identifier);
        IFEND;
      IFEND;
    IFEND;

    IF server_attributes^.sap_open THEN
      IF server_attributes^.server_titles <> NIL THEN
        osi_address.kind := nac$osi_transport_address;
        osi_address.transport_selector := server_attributes^.application_id.osi_sap_identifier;

        domain.kind := nac$catenet_domain;

        IF server_attributes^.protocol = nac$cdna_virtual_terminal THEN
          protocol := nac$cdna_virtual_terminal;
        ELSE
          protocol := nac$cdna_session;
        IFEND;

      /selected_titles/
        FOR i := 1 TO UPPERBOUND (server_attributes^.server_titles^) DO
          server_title := ^server_attributes^.server_titles^ [i];
          user_identifier := server_attributes^.server;
          nlp$register_title (server_title^.title, osi_address, protocol, ^server_title^.data,
                server_title^.data_length, server_title^.priority, domain, server_title^.distribute_title,
                nac$cdna_external, default_directory_password, user_identifier, server_title^.directory_id,
                status);
          IF NOT status.normal THEN
            nap$display_message (status);
            deactivate_server (server_attributes, TRUE);
            EXIT /selected_titles/; {----->
          IFEND;
        FOREND /selected_titles/;
      IFEND;
    IFEND;

    IF (status.normal) AND (NOT server_attributes^.nam_initiated_server) THEN
      server_attributes^.protocol_activated := TRUE;
    IFEND;

  PROCEND activate_server;

?? TITLE := 'assign_sap_identifier', EJECT ??

  PROCEDURE assign_sap_identifier
    (    reserved_sap: boolean;
     VAR sap_identifier { input, output} : nlt$ta_sap_selector;
     VAR status: ost$status);

    VAR
      i: integer;

    status.normal := TRUE;
    osp$set_job_signature_lock (nav$assigned_sap_list.lock);
    IF reserved_sap THEN
      IF (sap_identifier >= LOWERBOUND (nav$assigned_sap_list.reserved_sap)) AND
            (sap_identifier <= UPPERBOUND (nav$assigned_sap_list.reserved_sap)) THEN
        IF nav$assigned_sap_list.reserved_sap [sap_identifier] = nac$unassigned THEN
          nav$assigned_sap_list.reserved_sap [sap_identifier] := nac$assigned;
        ELSE { sap identifier already assigned
          osp$set_status_condition (nae$sap_already_open, status);
          osp$append_status_integer (osc$status_parameter_delimiter, sap_identifier, 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
        i := nav$assigned_sap_list.last_assigned_sap;
        REPEAT
          i := i + 1;
          IF i > UPPERBOUND (nav$assigned_sap_list.sap) THEN
            i := LOWERBOUND (nav$assigned_sap_list.sap);
          IFEND;
          IF nav$assigned_sap_list.sap [i] = nac$unassigned THEN
            nav$assigned_sap_list.sap [i] := nac$assigned;
            sap_identifier := i;
            nav$assigned_sap_list.last_assigned_sap := i;
            EXIT /search_for_available_sap/; {----->
          IFEND;
        UNTIL i = nav$assigned_sap_list.last_assigned_sap;
        osp$set_status_condition (nae$maximum_saps_open, status);
      END /search_for_available_sap/;
    IFEND;
    osp$clear_job_signature_lock (nav$assigned_sap_list.lock);
  PROCEND assign_sap_identifier;
?? TITLE := 'attach_server_application', EJECT ??

  PROCEDURE attach_server_application
    (    system_job_name: jmt$system_supplied_name;
         server: nat$application_name;
         max_connections: nat$number_of_connections;
     VAR status: ost$status);

    VAR
      server_job_attributes: ^nat$server_job_attributes,
      connection_count: nat$number_of_connections,
      duplicate_sign_on: boolean,
      i: integer,
      ignore_status: ost$status,
      server_attributes: ^nat$server_attributes;


    status.normal := TRUE;

    nap$find_server_attributes (server, server_attributes);
    IF server_attributes = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
    ELSE
      nlp$get_exclusive_access (server_attributes^.access_control);
      nap$validate_user (server_attributes^.server_capability, server_attributes^.server_ring,
            server_attributes^.server_system_privilege, status);
      IF NOT status.normal THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSEIF server_attributes^.server_status = nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_inactive, server, status);
      ELSE
        IF (NOT server_attributes^.nam_initiated_server) THEN
          server_job_attributes := server_attributes^.server_job_list;

          connection_count := 0;
          duplicate_sign_on := FALSE;
          WHILE server_job_attributes <> NIL DO
            IF server_job_attributes^.job_name = system_job_name THEN
              duplicate_sign_on := TRUE;
            IFEND;
            connection_count := connection_count + server_job_attributes^.max_connections_per_server_job;
            server_job_attributes := server_job_attributes^.next_entry;
          WHILEND;

          IF duplicate_sign_on THEN
            osp$set_status_abnormal (nac$status_id, nae$appl_already_attached, server, status);
          ELSEIF connection_count >= server_attributes^.max_connections THEN
            osp$set_status_abnormal (nac$status_id, nae$application_attach_limit, server, status);
          ELSE
            IF NOT server_attributes^.protocol_activated THEN
              activate_server (server_attributes, status);
            IFEND;

            IF status.normal THEN
              REPEAT
                ALLOCATE server_job_attributes IN nav$network_paged_heap^;
                IF server_job_attributes = NIL THEN
                  osp$end_subsystem_activity;
                  syp$cycle;
                  osp$begin_subsystem_activity;
                IFEND;
              UNTIL server_job_attributes <> NIL;
              server_job_attributes^.job_name := system_job_name;
              server_job_attributes^.job_status := nac$server_job_attached;
              server_job_attributes^.time_stamp := 0;
              server_job_attributes^.assigned_connection_count := 0;
              IF max_connections = 0 THEN
                server_job_attributes^.max_connections_per_server_job := server_attributes^.max_connections;
              ELSE
                server_job_attributes^.max_connections_per_server_job := max_connections;
              IFEND;

              server_job_attributes^.connection_count := 0;
              server_job_attributes^.next_entry := server_attributes^.server_job_list;
              server_attributes^.server_job_list := server_job_attributes;
            IFEND;
          IFEND;
        ELSE

{ Nam initiated server, find the matching initiated saj attributes.

        /await_saj_initialization/
          WHILE TRUE DO
            server_job_attributes := server_attributes^.server_job_list;

          /find_matching_saj/
            WHILE (server_job_attributes <> NIL) AND (server_job_attributes^.job_name <> system_job_name) DO
              server_job_attributes := server_job_attributes^.next_entry;
            WHILEND /find_matching_saj/;

            IF server_job_attributes <> NIL THEN
              IF server_attributes^.server_job_max_connections <> max_connections THEN
                osp$set_status_condition (nae$max_connections_mismatch, status);
              ELSE
                server_job_attributes^.max_connections_per_server_job := max_connections;
                server_job_attributes^.job_status := nac$server_job_attached;
                server_job_attributes^.time_stamp := 0;
              IFEND;
              EXIT /await_saj_initialization/; {----->
            ELSE

{ Wait for the polling task to add the server job attributes entry to the server attributes
{ entry. This is due to a race condition between the polling task and the newly initiated job
{ that is trying to attach to the server. The polling task leaves a flag in the server attributes
{ entry to indicate that the server attributes entry update is pending. The initiated job will
{ cycle until the server attributes entry has been updated.

              IF server_attributes^.server_job_init_pending THEN
                REPEAT
                  nlp$release_exclusive_access (server_attributes^.access_control);
                  syp$cycle;
                  nlp$get_exclusive_access (server_attributes^.access_control);

{ NOTE: Since the non exclusive access to the server attributes list is not released, the
{ server attributes entry cannot be deleted in the mean time. Hence no search is neccessary
{ to find the server attributes entry again.

                  IF server_attributes^.server_status = nac$application_inactive THEN
                    osp$set_status_abnormal (nac$status_id, nae$application_inactive,
                          server_attributes^.server, status);
                    EXIT /await_saj_initialization/; {----->
                  IFEND;
                UNTIL NOT server_attributes^.server_job_init_pending;
              ELSE
                osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
                EXIT /await_saj_initialization/; {----->
              IFEND;
            IFEND;
          WHILEND /await_saj_initialization/;
        IFEND;
      IFEND;
      nlp$release_exclusive_access (server_attributes^.access_control);
    IFEND;


  PROCEND attach_server_application;
?? TITLE := 'change_file_retention', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to change the retention period of a
{   file's next to the highest cycle.

  PROCEDURE change_file_retention
    (    path: pft$path;
         retention: pft$retention;
     VAR status: ost$status);

    VAR
      change_list: array [1 .. 1] of pft$change_descriptor,
      highest_cycle: fst$cycle_number,
      previous_high_cycle: pft$cycle_selector;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    status.normal := TRUE;
    find_highest_cycle_number (path, highest_cycle, status);
    IF status.normal THEN
      change_list [1].change_type := pfc$retention_change;
      change_list [1].retention := retention;
      previous_high_cycle.cycle_option := pfc$specific_cycle;
      previous_high_cycle.cycle_number := highest_cycle - 1;
      osp$establish_block_exit_hndlr (^handle_block_exit);
      pfp$begin_system_authority;
      pfp$change (path, previous_high_cycle, default_password, change_list, status);
      pfp$end_system_authority;
      osp$disestablish_cond_handler;
    IFEND;

  PROCEND change_file_retention;
?? TITLE := 'change_server_added_titles', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to build the server added titles list for
{   the new server attributes.
{ DESIGN:
{   Register each title from the old server added titles list with the new
{   title attributes and link it into the new server added titles list if the
{   title is not already registered.
{

  PROCEDURE change_server_added_titles
    (    old_added_titles: ^nat$added_title;
     VAR new_server_attributes: ^nat$server_attributes;
     VAR status: ost$status);

    VAR
      domain: nat$title_domain,
      new_added_title: ^nat$added_title,
      old_title: ^nat$added_title,
      protocol: nat$protocol,
      osi_address: nat$osi_registration_address,
      user_identifier: ost$name;

    status.normal := TRUE;
    domain.kind := nac$catenet_domain;
    protocol := new_server_attributes^.protocol;

    osi_address.kind := nac$osi_transport_address;
    osi_address.transport_selector := new_server_attributes^.application_id.osi_sap_identifier;

    old_title := old_added_titles;
    user_identifier := new_server_attributes^.server;

  /added_titles/
    WHILE old_title <> NIL DO
      REPEAT
        ALLOCATE new_added_title: [STRLENGTH (old_title^.title)] IN nav$network_paged_heap^;
        IF new_added_title = NIL THEN
          syp$cycle;
        IFEND;
      UNTIL new_added_title <> NIL;

      new_added_title^ := old_title^;
      nlp$register_title (new_added_title^.title, osi_address, protocol, ^new_added_title^.data,
            new_added_title^.data_length, new_added_title^.priority, domain,
            new_added_title^.distribute_title, nac$cdna_external, default_directory_password, user_identifier,
            new_added_title^.identifier, status);
      IF status.normal THEN
        new_added_title^.next_title := new_server_attributes^.added_titles;
        new_server_attributes^.added_titles := new_added_title;
      ELSEIF (status.condition = nae$duplicate_registration) THEN

{ If the title is already registered, do not link the title into server added
{ titles list of the new server attributes.

        status.normal := TRUE;
        FREE new_added_title IN nav$network_paged_heap^;
      ELSE
        EXIT /added_titles/; {----->
      IFEND;
      old_title := old_title^.next_title;
    WHILEND /added_titles/;

  PROCEND change_server_added_titles;
?? TITLE := 'close_and_change_cycle_1', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to close cycle 1 of the application file
{   and to change it to the highest cycle of the application file.
{   The retention period of the previous highest cycle is changed to two days.

  PROCEDURE close_and_change_cycle_1
    (    file_id: amt$file_identifier;
         file_pointer: amt$segment_pointer;
     VAR status: ost$status);

    VAR
      change_list: array [1 .. 1] of pft$change_descriptor,
      file_instance: ^bat$task_file_entry,
      file_name: amt$local_file_name,
      highest_cycle: fst$cycle_number,
      ignore_status: ost$status,
      previous_high_cycle: pft$cycle_selector;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    status.normal := TRUE;
    find_highest_cycle_number (application_file_path, highest_cycle, status);
    IF status.normal THEN
      change_list [1].change_type := pfc$cycle_number_change;
      change_list [1].cycle_number := highest_cycle + 1;

      amp$set_segment_eoi (file_id, file_pointer, status);
      IF status.normal THEN
        file_instance := baf$task_file_entry_p (file_id);
        file_name := file_instance^.local_file_name;
        fsp$close_file (file_id, ignore_status);
        amp$return (file_name, ignore_status);
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        pfp$change (application_file_path, cycle_1, default_password, change_list, status);
        IF status.normal THEN
          change_list [1].change_type := pfc$retention_change;
          change_list [1].retention := 2;
          previous_high_cycle.cycle_option := pfc$specific_cycle;
          previous_high_cycle.cycle_number := highest_cycle;
          pfp$change (application_file_path, previous_high_cycle, default_password, change_list, status);
        IFEND;
        pfp$end_system_authority;
        osp$disestablish_cond_handler;
      IFEND;
    IFEND;

  PROCEND close_and_change_cycle_1;
?? TITLE := 'close_cycle_1', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to close and delete cycle 1 of the
{   application definitions file.

  PROCEDURE close_cycle_1
    (    file_id: amt$file_identifier);

    VAR
      file_instance: ^bat$task_file_entry,
      file_name: amt$local_file_name,
      ignore_status: ost$status;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      pfp$end_system_authority;
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    file_instance := baf$task_file_entry_p (file_id);
    file_name := file_instance^.local_file_name;
    fsp$close_file (file_id, ignore_status);
    amp$return (file_name, ignore_status);
    osp$establish_block_exit_hndlr (^handle_block_exit);
    pfp$begin_system_authority;
    pfp$purge (application_file_path, cycle_1, default_password, ignore_status);
    pfp$end_system_authority;
    osp$disestablish_cond_handler;
  PROCEND close_cycle_1;
?? TITLE := 'convert_v10_client_to_v11', EJECT ??

  PROCEDURE convert_v10_client_to_v11
    (VAR v10_client_definition: ^nat$complete_client_definition;
     VAR v11_client_definition: ^nat$complete_client_definition);

{ This procedure converts a version 1.0 client definition into a version 1.1 definition. The new
{ definition is placed in a sequence allocated in the task private heap. It is the responsibility of
{ the calling procedure to free this space when it is no longer needed.

    VAR
      v10_client: ^nat$v10_client_definition,
      v11_client: ^nat$client_definition;

    RESET v10_client_definition;
    NEXT v10_client IN v10_client_definition;
    ALLOCATE v11_client_definition: [[nat$client_definition]] IN osv$task_private_heap^;
    NEXT v11_client IN v11_client_definition;
    v11_client^.client := v10_client^.client;
    v11_client^.client_status := v10_client^.client_status;
    IF v10_client^.protocol = nac$v10_cdna_session THEN
      v11_client^.protocol := nac$cdna_session;
    ELSEIF v10_client^.protocol = nac$v10_cdna_virtual_terminal THEN
      v11_client^.protocol := nac$cdna_virtual_terminal;
    ELSE
      v11_client^.protocol := nac$unknown_protocol;
    IFEND;
    v11_client^.reserved_application_id := v10_client^.reserved_application_id;
    v11_client^.application_id := v10_client^.application_id;
    v11_client^.max_connections := v10_client^.max_connections;
    v11_client^.client_capability := v10_client^.client_capability;
    v11_client^.client_ring := v10_client^.client_ring;
    v11_client^.client_system_privilege := v10_client^.client_system_privilege;
    v11_client^.message_priority := nac$default_message_priority;
    v11_client^.flags.nam_accounting := FALSE;

  PROCEND convert_v10_client_to_v11;
?? TITLE := 'convert_v10_server_to_v11', EJECT ??

  PROCEDURE convert_v10_server_to_v11
    (VAR v10_server_definition: ^nat$complete_server_definition;
     VAR v11_server_definition: ^nat$complete_server_definition);

{ This procedure converts a version 1.0 server definition into a version 1.1 definition. The new
{ definition is placed in a sequence allocated in the task private heap. It is the responsibility of
{ the calling procedure to free this space when it is no longer needed.

    VAR
      i: integer,
      size_of_client_addresses: integer,
      size_of_selected_titles: integer,
      v10_client_addresses: ^array [1 .. * ] of nat$v10_client_address,
      v11_client_addresses: ^array [1 .. * ] of nat$client_address,
      v10_server: ^nat$v10_server_definition,
      v11_server: ^nat$server_definition,
      v10_titles: ^nat$v10_selected_titles_list,
      v11_titles: ^nat$selected_titles_list;

    RESET v10_server_definition;
    NEXT v10_server IN v10_server_definition;
    size_of_selected_titles := #SIZE (nat$selected_title) * v10_server^.title_count;
    size_of_client_addresses := #SIZE (nat$client_address) * v10_server^.client_address_count;
    ALLOCATE v11_server_definition: [[REP (#SIZE (nat$server_definition) + size_of_selected_titles +
          size_of_client_addresses) OF cell]] IN osv$task_private_heap^;
    NEXT v11_server IN v11_server_definition;
    v11_server^.server := v10_server^.server;
    v11_server^.server_status := v10_server^.server_status;
    v11_server^.max_connections := v10_server^.max_connections;
    v11_server^.title_count := v10_server^.title_count;
    IF v11_server^.title_count > 0 THEN
      v10_titles := #PTR (v10_server^.selected_titles, v10_server_definition^);
      NEXT v11_titles: [1 .. v11_server^.title_count] IN v11_server_definition;
      FOR i := LOWERBOUND (v10_titles^) TO UPPERBOUND (v10_titles^) DO
        v11_titles^ [i].title := v10_titles^ [i].title;
        v11_titles^ [i].distribute_title := v10_titles^ [i].distribute_title;
        v11_titles^ [i].priority := nac$max_directory_priority;
        v11_titles^ [i].data_length := 0;
      FOREND;
      v11_server^.selected_titles := #REL (v11_titles, v11_server_definition^);
    IFEND;
    v11_server^.server_managed_title_count := 0;
    v11_server^.server_capability := v10_server^.server_capability;
    v11_server^.server_ring := v10_server^.server_ring;
    v11_server^.server_system_privilege := v10_server^.server_system_privilege;
    v11_server^.accept_connection := v10_server^.accept_connection;
    v11_server^.client_validation_capability := v10_server^.client_validation_capability;
    v11_server^.client_info_source := v10_server^.client_info_source;
    v11_server^.client_address_count := v10_server^.client_address_count;
    IF v11_server^.client_address_count > 0 THEN
      v10_client_addresses := #PTR (v10_server^.client_addresses, v10_server_definition^);
      NEXT v11_client_addresses: [1 .. v11_server^.client_address_count] IN v11_server_definition;
      FOR i := LOWERBOUND (v10_client_addresses^) TO UPPERBOUND (v10_client_addresses^) DO
        v11_client_addresses^ [i].network_id := v10_client_addresses^ [i].network_id;
        v11_client_addresses^ [i].system_kind := nac$any_system_kind;
        v11_client_addresses^ [i].system_id := v10_client_addresses^ [i].system_id;
        v11_client_addresses^ [i].reserved_application_id := v10_client_addresses^ [i].
              reserved_application_id;
        v11_client_addresses^ [i].application_id := v10_client_addresses^ [i].application_id;
      FOREND;
      v11_server^.client_addresses := #REL (v11_client_addresses, v11_server_definition^);
    IFEND;
    v11_server^.reserved_application_id := v10_server^.reserved_application_id;
    v11_server^.application_id := v10_server^.application_id;
    IF v10_server^.protocol = nac$v10_cdna_session THEN
      v11_server^.protocol := nac$cdna_session;
    ELSEIF v10_server^.protocol = nac$v10_cdna_virtual_terminal THEN
      v11_server^.protocol := nac$cdna_virtual_terminal;
    ELSE
      v11_server^.protocol := nac$unknown_protocol;
    IFEND;
    v11_server^.message_priority := nac$default_message_priority;
    v11_server^.flags.nam_accounting := FALSE;
    v11_server^.nam_initiated_server := v10_server^.nam_initiated_server;
    v11_server^.server_job_validation_source := v10_server^.server_job_validation_source;
    v11_server^.server_job_max_connections := v10_server^.server_job_max_connections;
    v11_server^.service_file_defined := v10_server^.service_file_defined;

  PROCEND convert_v10_server_to_v11;
?? TITLE := 'deactivate_client', EJECT ??

  PROCEDURE deactivate_client
    (    client_attributes: ^nat$client_attributes;
         terminate_active_connections: boolean);

    VAR
      client_connection: ^nat$client_connection_attribute,
      connection_released: boolean,
      ignore_status: ost$status,
      previous_client_connection: ^^nat$client_connection_attribute;

{ It is assumed that the client attributes list has been locked by the caller.

    IF terminate_active_connections THEN
      client_connection := client_attributes^.client_connections_list;
      previous_client_connection := ^client_attributes^.client_connections_list;
      WHILE client_connection <> NIL DO
        nap$se_terminate_connection (client_connection^.connection_id, nac$application_deactivated, TRUE,
              connection_released, ignore_status);
        IF connection_released THEN
          previous_client_connection^ := client_connection^.next_entry;
          FREE client_connection IN nav$network_paged_heap^;
          client_attributes^.connection_count := client_attributes^.connection_count - 1;
          client_connection := previous_client_connection^;
        ELSE
          client_connection := client_connection^.next_entry;
        IFEND;
      WHILEND;
    IFEND;

    IF (client_attributes^.sap_open) AND (client_attributes^.client_connections_list = NIL) THEN
      nlp$se_close_sap (client_attributes^.application_id, ignore_status);
      unassign_sap_identifier (client_attributes^.application_id.osi_sap_identifier);
      IF NOT client_attributes^.reserved_application_id THEN
        client_attributes^.application_id.osi_sap_identifier := 0;
      IFEND;
      client_attributes^.sap_open := FALSE;
    IFEND;

  PROCEND deactivate_client;
?? TITLE := 'deactivate_server', EJECT ??

  PROCEDURE deactivate_server
    (    server_attributes: ^nat$server_attributes;
         terminate_active_connections: boolean);

    VAR
      acquire_in_progress: ^nat$server_connection_attribute,
      added_title: ^nat$added_title,
      assigned_connection: ^nat$server_connection_attribute,
      connection_released: boolean,
      ignore_status: ost$status,
      i: integer,
      next_assigned_connection: ^nat$server_connection_attribute,
      next_title: ^nat$added_title,
      previous_job_attributes: ^^nat$server_job_attributes,
      previous_server_connection: ^^nat$server_connection_attribute,
      server_titles: ^nat$server_titles_list,
      server_connection: ^nat$server_connection_attribute,
      server_job_attributes: ^nat$server_job_attributes;

{ It is assumed that the server attributes list has been locked by the caller.

    IF server_attributes^.server_titles <> NIL THEN
      server_titles := server_attributes^.server_titles;
      FOR i := LOWERBOUND (server_titles^) TO UPPERBOUND (server_titles^) DO
        nlp$delete_registered_title (server_titles^ [i].title, default_directory_password,
              server_titles^ [i].directory_id, ignore_status);
      FOREND;
    IFEND;
    added_title := server_attributes^.added_titles;
    WHILE added_title <> NIL DO
      nlp$delete_registered_title (added_title^.title, default_directory_password, added_title^.identifier,
            ignore_status);
      next_title := added_title^.next_title;
      FREE added_title IN nav$network_paged_heap^;
      added_title := next_title;
    WHILEND;
    server_attributes^.added_titles := NIL;

    IF terminate_active_connections THEN

{    Terminate all server connections.

      server_connection := server_attributes^.server_connections_list;
      previous_server_connection := ^server_attributes^.server_connections_list;
      WHILE server_connection <> NIL DO
        nap$se_terminate_connection (server_connection^.connection_id, nac$application_deactivated, TRUE,
              connection_released, ignore_status);
        IF connection_released THEN
          previous_server_connection^ := server_connection^.next_entry;
          FREE server_connection IN nav$network_paged_heap^;
          server_attributes^.connection_count := server_attributes^.connection_count - 1;
          server_connection := previous_server_connection^;
        ELSE
          server_connection := server_connection^.next_entry;
        IFEND;
      WHILEND;

    IFEND;

{   Terminate connections assigned to the server.

    assigned_connection := server_attributes^.assigned_connections_list;
    WHILE assigned_connection <> NIL DO
      nap$se_terminate_connection (assigned_connection^.connection_id, nac$application_deactivated, FALSE,
            connection_released, ignore_status);
      next_assigned_connection := assigned_connection^.next_entry;
      FREE assigned_connection IN nav$network_paged_heap^;
      assigned_connection := next_assigned_connection;
      server_attributes^.connection_count := server_attributes^.connection_count - 1;
    WHILEND;
    server_attributes^.assigned_connections_list := NIL;

{ Mark the connections in the acquire_in_progress queue to be terminated by the
{ acquiring task. These connections cannot be terminated here because we do not
{ know it there is a file associated with the connection.

    acquire_in_progress := server_attributes^.acquire_in_progress;
    WHILE acquire_in_progress <> NIL DO
      acquire_in_progress^.terminate_connection := TRUE;
      acquire_in_progress := acquire_in_progress^.next_entry;
    WHILEND;

    server_job_attributes := server_attributes^.server_job_list;
    previous_job_attributes := ^server_attributes^.server_job_list;
    WHILE server_job_attributes <> NIL DO
      IF server_job_attributes^.job_status = nac$server_job_initiated THEN
        previous_job_attributes^ := server_job_attributes^.next_entry;
        FREE server_job_attributes IN nav$network_paged_heap^;
        server_job_attributes := previous_job_attributes^;
      ELSE
        server_job_attributes^.job_status := nac$server_job_deactivated;
        server_job_attributes^.assigned_connection_count := 0;
        previous_job_attributes := ^server_job_attributes^.next_entry;
        server_job_attributes := server_job_attributes^.next_entry;
      IFEND;
    WHILEND;

    IF (server_attributes^.sap_open) AND (server_attributes^.server_connections_list = NIL) AND
          (server_attributes^.acquire_in_progress = NIL) AND
          (server_attributes^.assigned_connections_list = NIL) THEN
      nlp$se_close_sap (server_attributes^.application_id, ignore_status);
      unassign_sap_identifier (server_attributes^.application_id.osi_sap_identifier);
      IF NOT server_attributes^.reserved_application_id THEN
        server_attributes^.application_id.osi_sap_identifier := 0;
      IFEND;
      server_attributes^.sap_open := FALSE;
    IFEND;

    IF NOT server_attributes^.nam_initiated_server THEN
      server_attributes^.protocol_activated := FALSE;
    IFEND;

  PROCEND deactivate_server;

?? TITLE := 'deactivate_tcpip', EJECT ??

{    The purpose of this procedure is to terminate assigned sockets.

  PROCEDURE deactivate_tcpip
    (    application: nat$application_name;
         protocol: nat$protocol;
         terminate_active_sockets: boolean;
         tcp_socket_list: ^array [1 .. * ] of nat$tcp_socket;
         udp_socket_list: ^array [1 .. * ] of nat$udp_socket);

    VAR
      connection_id: nat$connection_id,
      global_socket_id: nlt$udp_global_socket_id,
      i: integer,
      ignore_status: ost$status;

    IF protocol = nac$stream_socket THEN
      nlp$sk_tcp_terminate_all_listen (application);

      IF tcp_socket_list <> NIL THEN
        FOR i := 1 TO UPPERBOUND (tcp_socket_list^) DO
          IF (NOT tcp_socket_list^ [i].socket_assigned) OR (terminate_active_sockets) THEN
            nlp$sk_tcp_terminate_socket (tcp_socket_list^ [i].connection_id);
            nlp$tcpip_decrement_appl_access (application, global_socket_id, tcp_socket_list^ [i].
                  connection_id, ignore_status);
          IFEND;
        FOREND;
      IFEND;

    ELSEIF (terminate_active_sockets) AND (udp_socket_list <> NIL) THEN
      FOR i := 1 TO UPPERBOUND (udp_socket_list^) DO
        nlp$udp_close_socket (udp_socket_list^ [i].global_socket_id, TRUE);
        nlp$tcpip_decrement_appl_access (application, udp_socket_list^ [i].global_socket_id, connection_id,
              ignore_status);
      FOREND;
    IFEND;

  PROCEND deactivate_tcpip;
?? TITLE := 'define_client_attributes_entry', EJECT ??

  PROCEDURE define_client_attributes_entry
    (    client_definition: ^nat$client_definition;
     VAR client_attributes: ^nat$client_attributes);

    REPEAT
      ALLOCATE client_attributes IN nav$network_paged_heap^;
      IF client_attributes = NIL THEN
        syp$cycle;
      IFEND;
    UNTIL client_attributes <> NIL;
    client_attributes^.access_control := initialize_access_control;
    client_attributes^.next_entry := NIL;
    client_attributes^.client := client_definition^.client;
    client_attributes^.client_status := client_definition^.client_status;
    client_attributes^.client_capability := client_definition^.client_capability;
    client_attributes^.client_ring := client_definition^.client_ring;
    client_attributes^.client_system_privilege := client_definition^.client_system_privilege;
    client_attributes^.max_connections := client_definition^.max_connections;
    client_attributes^.connection_count := 0;
    client_attributes^.attempted_connection_count := 0;
    client_attributes^.rejected_connection_attempts := 0;
    client_attributes^.protocol := client_definition^.protocol;
    client_attributes^.message_priority := client_definition^.message_priority;
    client_attributes^.flags.nam_accounting := FALSE;
    client_attributes^.reserved_application_id := client_definition^.reserved_application_id;
    IF client_attributes^.reserved_application_id THEN
      client_attributes^.application_id.xns_sap_identifier := client_definition^.application_id;
      client_attributes^.application_id.osi_sap_identifier :=
            (client_definition^.application_id - minimum_xns_sap_identifier) + nlc$ta_min_rsvd_se_session_sap;
    IFEND;
    client_attributes^.sap_open := FALSE;
    client_attributes^.client_connections_list := NIL;

  PROCEND define_client_attributes_entry;
?? TITLE := 'define_server_attributes_entry', EJECT ??

  PROCEDURE define_server_attributes_entry
    (VAR complete_server_definition: ^nat$complete_server_definition;
     VAR server_attributes: ^nat$server_attributes);

    VAR
      binary_mainframe_id: pmt$binary_mainframe_id,
      client_addresses: ^array [1 .. * ] of nat$client_address,
      i: integer,
      selected_titles: ^nat$selected_titles_list,
      server_definition: ^nat$server_definition,
      server_managed_titles: ^nat$title_pattern_list,
      timesharing_title: ost$name,
      title_count: integer;

    RESET complete_server_definition;
    NEXT server_definition IN complete_server_definition;
    REPEAT
      ALLOCATE server_attributes IN nav$network_paged_heap^;
      IF server_attributes = NIL THEN
        syp$cycle;
      IFEND;
    UNTIL server_attributes <> NIL;
    server_attributes^.access_control := initialize_access_control;
    server_attributes^.next_entry := NIL;
    server_attributes^.server := server_definition^.server;
    server_attributes^.server_status := server_definition^.server_status;
    server_attributes^.max_connections := server_definition^.max_connections;
    IF (server_definition^.title_count > 0) OR (server_definition^.server = osc$timesharing) THEN
      selected_titles := #PTR (server_definition^.selected_titles, complete_server_definition^);
      IF server_definition^.server = osc$timesharing THEN
        title_count := server_definition^.title_count + 1;
      ELSE
        title_count := server_definition^.title_count;
      IFEND;
      REPEAT
        ALLOCATE server_attributes^.server_titles: [1 .. title_count] IN nav$network_paged_heap^;
        IF server_attributes^.server_titles = NIL THEN
          syp$cycle;
        IFEND;
      UNTIL server_attributes^.server_titles <> NIL;
      FOR i := 1 TO server_definition^.title_count DO
        server_attributes^.server_titles^ [i].title := selected_titles^ [i].title;
        server_attributes^.server_titles^ [i].distribute_title := selected_titles^ [i].distribute_title;
        server_attributes^.server_titles^ [i].priority := selected_titles^ [i].priority;
        server_attributes^.server_titles^ [i].data_length := selected_titles^ [i].data_length;
        server_attributes^.server_titles^ [i].data := selected_titles^ [i].data;
      FOREND;
      IF server_definition^.server = osc$timesharing THEN
        pmp$get_pseudo_mainframe_id (binary_mainframe_id);
        jmp$generate_timesharing_title (binary_mainframe_id, timesharing_title);
        server_attributes^.server_titles^ [title_count].title := timesharing_title;
        server_attributes^.server_titles^ [title_count].distribute_title := FALSE;
        server_attributes^.server_titles^ [title_count].priority := nac$max_directory_priority;
        server_attributes^.server_titles^ [title_count].data_length := 0;
      IFEND;
    ELSE
      server_attributes^.server_titles := NIL;
    IFEND;
    IF server_definition^.server_managed_title_count > 0 THEN
      server_managed_titles := #PTR (server_definition^.server_managed_titles, complete_server_definition^);
      REPEAT
        ALLOCATE server_attributes^.server_managed_titles: [1 .. server_definition^.
              server_managed_title_count] IN nav$network_paged_heap^;
        IF server_attributes^.server_managed_titles = NIL THEN
          syp$cycle;
        IFEND;
      UNTIL server_attributes^.server_managed_titles <> NIL;
      FOR i := 1 TO server_definition^.server_managed_title_count DO
        server_attributes^.server_managed_titles^ [i] := server_managed_titles^ [i];
      FOREND;
    ELSE
      server_attributes^.server_managed_titles := NIL;
    IFEND;

    server_attributes^.added_titles := NIL;
    server_attributes^.server_capability := server_definition^.server_capability;
    server_attributes^.server_ring := server_definition^.server_ring;
    server_attributes^.server_system_privilege := server_definition^.server_system_privilege;
    server_attributes^.accept_connection := server_definition^.accept_connection;
    server_attributes^.client_validation_capability := server_definition^.client_validation_capability;
    server_attributes^.client_info_source := server_definition^.client_info_source;
    IF server_definition^.client_address_count > 0 THEN
      client_addresses := #PTR (server_definition^.client_addresses, complete_server_definition^);
      REPEAT
        ALLOCATE server_attributes^.client_addresses: [1 .. server_definition^.client_address_count] IN
              nav$network_paged_heap^;
        IF server_attributes^.client_addresses = NIL THEN
          syp$cycle;
        IFEND;
      UNTIL server_attributes^.client_addresses <> NIL;
      server_attributes^.client_addresses^ := client_addresses^;
    ELSE
      server_attributes^.client_addresses := NIL;
    IFEND;

    server_attributes^.reserved_application_id := server_definition^.reserved_application_id;
    IF server_attributes^.reserved_application_id THEN
      server_attributes^.application_id.xns_sap_identifier := server_definition^.application_id;
      server_attributes^.application_id.osi_sap_identifier :=
            (server_definition^.application_id - minimum_xns_sap_identifier) + nlc$ta_min_rsvd_se_session_sap;
    IFEND;
    server_attributes^.sap_open := FALSE;
    server_attributes^.message_priority := server_definition^.message_priority;
    server_attributes^.flags.nam_accounting := FALSE;
    server_attributes^.protocol := server_definition^.protocol;
    server_attributes^.server_connections_list := NIL;
    server_attributes^.connection_count := 0;
    server_attributes^.attempted_connection_count := 0;
    server_attributes^.rejected_connection_attempts := 0;
    server_attributes^.wait_for_connection := NIL;
    server_attributes^.assigned_connections_list := NIL;
    server_attributes^.acquire_in_progress := NIL;
    server_attributes^.server_job_list := NIL;
    server_attributes^.nam_initiated_server := server_definition^.nam_initiated_server;
    IF server_attributes^.nam_initiated_server THEN
      server_attributes^.server_job_validation_source := server_definition^.server_job_validation_source;
      server_attributes^.server_job_max_connections := server_definition^.server_job_max_connections;
      server_attributes^.service_file_defined := server_definition^.service_file_defined;
      server_attributes^.server_job_init_pending := FALSE;
    ELSE
      server_attributes^.protocol_activated := FALSE;
    IFEND;

  PROCEND define_server_attributes_entry;
?? TITLE := 'define_server_job_file', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to define a file by the server name to hold
{   the scl commands that make up the server job.

  PROCEDURE define_server_job_file
    (    path: pft$path;
         server_job: amt$local_file_name;
     VAR status: ost$status);

    VAR
      ignore_status: ost$status,
      output_creation_attributes: array [1 .. 1] of fst$file_cycle_attribute,
      unique_name: ost$name;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    status.normal := TRUE;
    pmp$get_unique_name (unique_name, ignore_status);
    osp$establish_block_exit_hndlr (^handle_block_exit);
    pfp$begin_system_authority;
    pfp$define (unique_name, path, highest_cycle, default_password, pfc$maximum_retention, pfc$no_log,
          status);
    IF NOT status.normal THEN
      pfp$end_system_authority;
      osp$disestablish_cond_handler;
      RETURN; {----->
    IFEND;

{ Change the ring attributes so that the server job file is readable from
{ ring 13.

    output_creation_attributes [1].selector := fsc$ring_attributes;
    output_creation_attributes [1].ring_attributes.r1 := osc$tsrv_ring;
    output_creation_attributes [1].ring_attributes.r2 := osc$user_ring_2;
    output_creation_attributes [1].ring_attributes.r3 := osc$user_ring_2;
    fsp$copy_file (server_job, unique_name, NIL, NIL, ^output_creation_attributes, status);
    IF NOT status.normal THEN
      pfp$purge (path, highest_cycle, default_password, ignore_status);
    IFEND;
    pfp$end_system_authority;
    osp$disestablish_cond_handler;
    amp$return (unique_name, ignore_status);

  PROCEND define_server_job_file;
?? TITLE := 'define_tcpip_attributes_entry', EJECT ??

{    The purpose of this procedure is to initialize the attributes
{    entry for a tcpip application.

  PROCEDURE define_tcpip_attributes_entry
    (    tcpip_definition: ^nat$tcpip_definition;
     VAR tcpip_attributes: ^nat$tcpip_attributes);

    REPEAT
      ALLOCATE tcpip_attributes IN nav$network_paged_heap^;
      IF tcpip_attributes = NIL THEN
        syp$cycle;
      IFEND;
    UNTIL tcpip_attributes <> NIL;
    tcpip_attributes^.access_control := initialize_access_control;
    tcpip_attributes^.next_entry := NIL;
    tcpip_attributes^.tcpip_application := tcpip_definition^.tcpip_application;
    tcpip_attributes^.tcpip_status := tcpip_definition^.tcpip_status;
    tcpip_attributes^.tcpip_capability := tcpip_definition^.tcpip_capability;
    tcpip_attributes^.tcpip_ring := tcpip_definition^.tcpip_ring;
    tcpip_attributes^.tcpip_system_privilege := tcpip_definition^.tcpip_system_privilege;
    tcpip_attributes^.maximum_sockets := tcpip_definition^.maximum_sockets;
    tcpip_attributes^.active_socket_count := 0;
    tcpip_attributes^.socket_attempt_count := 0;
    tcpip_attributes^.socket_reject_count := 0;
    tcpip_attributes^.protocol := tcpip_definition^.protocol;
    tcpip_attributes^.flags.nam_accounting := FALSE;
    IF tcpip_attributes^.protocol = nac$stream_socket THEN
      tcpip_attributes^.tcp_socket_list := NIL;
    ELSE
      tcpip_attributes^.udp_socket_list := NIL;
    IFEND;

  PROCEND define_tcpip_attributes_entry;
?? TITLE := 'delete_server_added_titles', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to delete the registration of the titles
{   in the added titles list.
{ NOTES:
{   It is assumed that the server attributes list has been locked by the caller.

  PROCEDURE delete_server_added_titles
    (    added_title: ^nat$added_title);

    VAR
      ignore_status: ost$status,
      next_title: ^nat$added_title;

    next_title := added_title;
    WHILE next_title <> NIL DO
      nlp$delete_registered_title (next_title^.title, default_directory_password, next_title^.identifier,
            ignore_status);
      next_title := next_title^.next_title;
    WHILEND;

  PROCEND delete_server_added_titles;
?? TITLE := 'delete_server_titles', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to delete the registration of the titles
{   in the server titles list.
{ NOTES:
{   It is assumed that the server attributes list has been locked by the caller.

  PROCEDURE delete_server_titles
    (    server_titles: ^nat$server_titles_list);

    VAR
      i: 1 .. 255,
      ignore_status: ost$status;

    IF server_titles <> NIL THEN
      FOR i := LOWERBOUND (server_titles^) TO UPPERBOUND (server_titles^) DO
        nlp$delete_registered_title (server_titles^ [i].title, default_directory_password,
              server_titles^ [i].directory_id, ignore_status);
      FOREND;
    IFEND;

  PROCEND delete_server_titles;
?? TITLE := 'detach_server_application', EJECT ??

  PROCEDURE detach_server_application
    (    system_job_name: jmt$system_supplied_name;
         server: nat$application_name;
     VAR status: ost$status);

    VAR
      previous_server_job_attributes: ^^nat$server_job_attributes,
      previous_wait_for_connection: ^^nat$wait_for_connection,
      server_attributes: ^nat$server_attributes,
      server_connection: ^nat$server_connection_attribute,
      server_job_attributes: ^nat$server_job_attributes,
      wait_for_connection: ^nat$wait_for_connection;

    status.normal := TRUE;

    nap$find_server_attributes (server, server_attributes);
    IF server_attributes = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
    ELSE
      nlp$get_exclusive_access (server_attributes^.access_control);
      nap$validate_user (server_attributes^.server_capability, server_attributes^.server_ring,
            server_attributes^.server_system_privilege, status);
      IF NOT status.normal THEN
        nap$display_message (status);
        osp$set_status_abnormal (nac$status_id, nae$server_not_attached, server, status);
      ELSE
        server_job_attributes := server_attributes^.server_job_list;
        previous_server_job_attributes := ^server_attributes^.server_job_list;
        WHILE (server_job_attributes <> NIL) AND (server_job_attributes^.job_name <> system_job_name) DO
          previous_server_job_attributes := ^server_job_attributes^.next_entry;
          server_job_attributes := server_job_attributes^.next_entry;
        WHILEND;
        IF server_job_attributes = NIL THEN
          osp$set_status_abnormal (nac$status_id, nae$server_not_attached, server, status);
        ELSE
          previous_server_job_attributes^ := server_job_attributes^.next_entry;

{ Change job connections to server connections.

          IF server_job_attributes^.connection_count > 0 THEN
            server_connection := server_attributes^.server_connections_list;

          /search/
            WHILE server_connection <> NIL DO
              IF (server_connection^.connection_kind = nac$owned_by_job) AND
                    (server_connection^.job_name = server_job_attributes^.job_name) THEN
                server_connection^.connection_kind := nac$owned_by_server;
              IFEND;
              server_connection := server_connection^.next_entry;
            WHILEND /search/;
          IFEND;

          IF server_attributes^.wait_for_connection <> NIL THEN
            previous_wait_for_connection := ^server_attributes^.wait_for_connection;
            wait_for_connection := server_attributes^.wait_for_connection;
            WHILE (wait_for_connection <> NIL) AND (wait_for_connection^.job_name <> system_job_name) DO
              previous_wait_for_connection := ^wait_for_connection^.next_entry;
              wait_for_connection := wait_for_connection^.next_entry;
            WHILEND;
            IF wait_for_connection <> NIL THEN
              previous_wait_for_connection^ := wait_for_connection^.next_entry;
              FREE wait_for_connection IN nav$network_paged_heap^;

{ *** DEBUG   pmp$log ('AM - Task removed from wait for conn q.', ignore_status);

            IFEND;
          IFEND;

          FREE server_job_attributes IN nav$network_paged_heap^;

{ For a self initiated server the last job detaching from the server should also
{ deactivate the server.

          IF (NOT server_attributes^.nam_initiated_server) AND (server_attributes^.server_job_list = NIL) AND
                (server_attributes^.protocol_activated) THEN
            deactivate_server (server_attributes, FALSE);
          IFEND;
        IFEND;
      IFEND;
      nlp$release_exclusive_access (server_attributes^.access_control);
    IFEND;

  PROCEND detach_server_application;

?? TITLE := 'display_message_to_$response', EJECT ??

{ PURPOSE
{   Format and display a NOS/VE status condition.
{ DESIGN
{   The message status is formatted with calls to system routines and written
{   to the $RESPONSE file.

  PROCEDURE display_message_to_$response
    (    message_status: ost$status;
     VAR status: ost$status);

    VAR
      attachment_selections: [STATIC, READ, oss$job_paged_literal] array [1 .. 1] of
            fst$attachment_option := [[fsc$access_and_share_modes,
            [fsc$specific_access_modes, [fsc$shorten, fsc$append, fsc$modify]], [fsc$required_share_modes]]],
      byte_address: amt$file_byte_address,
      error_file_id: [STATIC] amt$file_identifier,
      error_file_name: [STATIC, READ, oss$job_paged_literal] amt$local_file_name := '$RESPONSE',
      error_file_opened: [STATIC] boolean := FALSE,
      ignore_status: ost$status,
      length_pointer: ^ost$status_message_line_size,
      line_count_pointer: ^ost$status_message_line_count,
      line_index: ost$status_message_line_count,
      message: ost$status_message,
      message_sequence: ^ost$status_message,
      text_pointer: ^ost$status_message_line;

    IF NOT error_file_opened THEN
      fsp$open_file (error_file_name, amc$record, ^attachment_selections, {default_creation_attributes =} NIL,
            {mandated_creation_attributes =} NIL, {attribute_validation =} NIL, {attribute_override =} NIL,
            error_file_id, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      error_file_opened := TRUE;
    IFEND;

    osp$format_message (message_status, osc$current_message_level, osc$max_status_message_line, message,
          status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    message_sequence := ^message;
    RESET message_sequence;
    NEXT line_count_pointer IN message_sequence;

    FOR line_index := 1 TO line_count_pointer^ DO
      NEXT length_pointer IN message_sequence;
      NEXT text_pointer: [length_pointer^] IN message_sequence;
      amp$put_next (error_file_id, text_pointer, length_pointer^, byte_address, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    FOREND;

  PROCEND display_message_to_$response;
?? TITLE := 'find_client_definition', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to find the pointer to the definition of the given client on the
{   application file. If it is not found or is in error, a NIL pointer is returned.

  PROCEDURE find_client_definition
    (    client: nat$application_name;
     VAR application_file: ^SEQ ( * );
     VAR complete_client_definition: ^nat$complete_client_definition);

    VAR
      client_definition: ^nat$client_definition,
      client_pointers: ^nat$client_pointers,
      file_header: ^nat$application_file_header,
      i: integer,
      server_pointers: ^nat$server_pointers,
      v10_client_definition: ^nat$v10_client_definition,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    complete_client_definition := NIL;
    RESET application_file;
    NEXT file_header IN application_file;
    IF file_header^.version <> nac$application_file_version THEN
      RESET application_file;
      NEXT v10_v11_file_header IN application_file;
    IFEND;
    IF file_header^.server_count > 0 THEN
      NEXT server_pointers: [1 .. file_header^.server_count] IN application_file;
    IFEND;
    IF file_header^.client_count > 0 THEN
      NEXT client_pointers: [1 .. file_header^.client_count] IN application_file;

    /search/
      FOR i := 1 TO file_header^.client_count DO
        IF client_pointers^ [i].client = client THEN
          complete_client_definition := #PTR (client_pointers^ [i].pointer, application_file^);
          RESET complete_client_definition;
          IF (file_header^.version = nac$application_file_version) OR
                (file_header^.version = nac$v11_appl_file_version) THEN
            NEXT client_definition IN complete_client_definition;
            RESET complete_client_definition;
            IF (client_definition <> NIL) AND (client <> client_definition^.client) THEN
              complete_client_definition := NIL;
            IFEND;
          ELSEIF file_header^.version = nac$v10_appl_file_version THEN
            NEXT v10_client_definition IN complete_client_definition;
            RESET complete_client_definition;
            IF (v10_client_definition <> NIL) AND (client <> v10_client_definition^.client) THEN
              complete_client_definition := NIL;
            IFEND;
          ELSE
            complete_client_definition := NIL;
          IFEND;
          EXIT /search/; {----->
        IFEND;
      FOREND /search/;
    IFEND;

  PROCEND find_client_definition;
?? TITLE := 'find_highest_cycle_number', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to find the highest cycle number of the
{   given file.

  PROCEDURE find_highest_cycle_number
    (    path: pft$path;
     VAR cycle_number: fst$cycle_number;
     VAR status: ost$status);

    VAR
      body: pft$p_info,
      catalog_info_selections: pft$catalog_info_selections,
      cycle_array: pft$p_cycle_array,
      cycle_index: pft$array_index,
      directory_array: pft$p_directory_array,
      file_info_selections: pft$file_info_selections,
      group: pft$group,
      info_record: pft$p_info_record,
      item_record: pft$p_info_record,
      local_status: ost$status,
      segment_pointer: amt$segment_pointer;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    status.normal := TRUE;
    mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_random, segment_pointer, status);
    IF status.normal THEN
      cycle_array := NIL;
      group.group_type := pfc$public;
      catalog_info_selections := $pft$catalog_info_selections [];
      file_info_selections := $pft$file_info_selections [pfc$file_directory, pfc$file_description,
            pfc$file_cycles];
      osp$establish_block_exit_hndlr (^handle_block_exit);
      pfp$begin_system_authority;
      pfp$get_item_info (path, group, catalog_info_selections, file_info_selections,
            segment_pointer.sequence_pointer, status);
      pfp$end_system_authority;
      osp$disestablish_cond_handler;
      IF status.normal THEN
        RESET segment_pointer.sequence_pointer;
        pfp$find_next_info_record (segment_pointer.sequence_pointer, info_record, status);
        IF status.normal THEN
          pfp$find_directory_array (info_record, directory_array, status);
          IF status.normal AND (directory_array <> NIL) THEN
            body := ^info_record^.body;
            pfp$find_direct_info_record (body, directory_array^ [LOWERBOUND (directory_array^)].info_offset,
                  item_record, status);
            IF status.normal THEN
              pfp$find_cycle_array (item_record, cycle_array, status);
              IF status.normal THEN
                pfp$find_cycle_entry (cycle_array, highest_cycle, cycle_index, status);
                IF status.normal THEN
                  cycle_number := cycle_array^ [cycle_index].cycle_number;
                IFEND;
              IFEND;
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
    mmp$delete_scratch_segment (segment_pointer, local_status);

  PROCEND find_highest_cycle_number;
?? TITLE := 'find_server_definition', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to find the pointer to the definition of the given server on the
{   application file. If it is not found or is in error, a NIL pointer is returned.

  PROCEDURE find_server_definition
    (    server: nat$application_name;
     VAR sequence_pointer: ^SEQ ( * );
     VAR complete_server_definition: ^nat$complete_server_definition);

    VAR
      file_header: ^nat$application_file_header,
      i: integer,
      server_definition: ^nat$server_definition,
      server_pointers: ^nat$server_pointers,
      v10_server_definition: ^nat$v10_server_definition,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    complete_server_definition := NIL;
    RESET sequence_pointer;
    NEXT file_header IN sequence_pointer;
    IF file_header^.version <> nac$application_file_version THEN
      RESET sequence_pointer;
      NEXT v10_v11_file_header IN sequence_pointer;
    IFEND;
    IF file_header^.server_count > 0 THEN
      NEXT server_pointers: [1 .. file_header^.server_count] IN sequence_pointer;

    /search/
      FOR i := 1 TO file_header^.server_count DO
        IF server_pointers^ [i].server = server THEN
          complete_server_definition := #PTR (server_pointers^ [i].pointer, sequence_pointer^);
          RESET complete_server_definition;
          IF (file_header^.version = nac$application_file_version) OR
                (file_header^.version = nac$v11_appl_file_version) THEN
            NEXT server_definition IN complete_server_definition;
            RESET complete_server_definition;
            IF (server_definition <> NIL) AND (server <> server_definition^.server) THEN
              complete_server_definition := NIL;
            IFEND;
          ELSEIF file_header^.version = nac$v10_appl_file_version THEN
            NEXT v10_server_definition IN complete_server_definition;
            RESET complete_server_definition;
            IF (v10_server_definition <> NIL) AND (server <> v10_server_definition^.server) THEN
              complete_server_definition := NIL;
            IFEND;
          ELSE
            complete_server_definition := NIL;
          IFEND;
          EXIT /search/; {----->
        IFEND;
      FOREND /search/;
    IFEND;

  PROCEND find_server_definition;
?? TITLE := 'find_tcpip_definition', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to find the pointer to the definition of the given
{   tcpip application on the application file. If it is not found or is in error,
{   a NIL pointer is returned.

  PROCEDURE find_tcpip_definition
    (    application: nat$application_name;
     VAR application_file: ^SEQ ( * );
     VAR complete_tcpip_definition: ^nat$complete_tcpip_definition);

    VAR
      client_pointers: ^nat$client_pointers,
      file_header: ^nat$application_file_header,
      i: integer,
      server_pointers: ^nat$server_pointers,
      tcpip_definition: ^nat$tcpip_definition,
      tcpip_pointers: ^nat$tcpip_pointers;

    complete_tcpip_definition := NIL;
    RESET application_file;
    NEXT file_header IN application_file;
    IF file_header^.version = nac$application_file_version THEN
      IF file_header^.server_count > 0 THEN
        NEXT server_pointers: [1 .. file_header^.server_count] IN application_file;
      IFEND;
      IF file_header^.client_count > 0 THEN
        NEXT client_pointers: [1 .. file_header^.client_count] IN application_file;
      IFEND;
      IF file_header^.tcpip_count > 0 THEN
        NEXT tcpip_pointers: [1 .. file_header^.tcpip_count] IN application_file;

      /search/
        FOR i := 1 TO file_header^.tcpip_count DO
          IF tcpip_pointers^ [i].application = application THEN
            complete_tcpip_definition := #PTR (tcpip_pointers^ [i].pointer, application_file^);
            RESET complete_tcpip_definition;
            NEXT tcpip_definition IN complete_tcpip_definition;
            RESET complete_tcpip_definition;
            IF (tcpip_definition <> NIL) AND (application <> tcpip_definition^.tcpip_application) THEN
              complete_tcpip_definition := NIL;
            IFEND;
            EXIT /search/; {----->
          IFEND;
        FOREND /search/;
      IFEND;
    IFEND;
  PROCEND find_tcpip_definition;

?? TITLE := 'free_server_attributes', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to free the space allocated in the
{   network paged segment for the server titles, the server managed titles,
{   the client addresses and the server added titles.

  PROCEDURE free_server_attributes
    (    free_added_titles: boolean;
         free_server_titles: boolean;
     VAR server_attributes: ^nat$server_attributes);

    VAR
      added_title: ^nat$added_title,
      next_title: ^nat$added_title;

    IF free_server_titles THEN
      IF server_attributes^.server_titles <> NIL THEN
        FREE server_attributes^.server_titles IN nav$network_paged_heap^;
      IFEND;
    IFEND;

    IF server_attributes^.server_managed_titles <> NIL THEN
      FREE server_attributes^.server_managed_titles IN nav$network_paged_heap^;
    IFEND;

    IF server_attributes^.client_addresses <> NIL THEN
      FREE server_attributes^.client_addresses IN nav$network_paged_heap^;
    IFEND;

    IF free_added_titles THEN
      added_title := server_attributes^.added_titles;
      WHILE added_title <> NIL DO
        next_title := added_title^.next_title;
        FREE added_title IN nav$network_paged_heap^;
        added_title := next_title;
      WHILEND;
    IFEND;

  PROCEND free_server_attributes;
?? TITLE := 'free_server_attributes_entry', EJECT ??

  PROCEDURE [INLINE] free_server_attributes_entry
    (VAR server_attributes: ^nat$server_attributes);

    IF server_attributes^.server_titles <> NIL THEN
      FREE server_attributes^.server_titles IN nav$network_paged_heap^;
    IFEND;

    IF server_attributes^.server_managed_titles <> NIL THEN
      FREE server_attributes^.server_managed_titles IN nav$network_paged_heap^;
    IFEND;

    IF server_attributes^.client_addresses <> NIL THEN
      FREE server_attributes^.client_addresses IN nav$network_paged_heap^;
    IFEND;

    FREE server_attributes IN nav$network_paged_heap^;

  PROCEND free_server_attributes_entry;
?? TITLE := 'move_server_definition', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to move a server definition from the
{   old application definition file to the new application definition file.

  PROCEDURE move_server_definition
    (    old_server: nat$server_pointer;
     VAR new_server: nat$server_pointer;
     VAR old_application_file: ^SEQ ( * );
     VAR new_application_file: ^SEQ ( * ));

    VAR
      converted_server_definition: ^nat$complete_server_definition,
      new_server_definition: ^nat$complete_server_definition,
      old_file_header: ^nat$application_file_header,
      old_server_definition: ^nat$complete_server_definition;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;

    old_server_definition := #PTR (old_server.pointer, old_application_file^);
    IF (old_file_header^.version = nac$application_file_version) OR
          (old_file_header^.version = nac$v11_appl_file_version) THEN
      new_server.server := old_server.server;
      NEXT new_server_definition: [[REP #SIZE (old_server_definition^) OF cell]] IN new_application_file;
      new_server.pointer := #REL (new_server_definition, new_application_file^);
      new_server_definition^ := old_server_definition^;
    ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
      convert_v10_server_to_v11 (old_server_definition, converted_server_definition);
      new_server.server := old_server.server;
      NEXT new_server_definition: [[REP #SIZE (converted_server_definition^) OF cell]] IN
            new_application_file;
      new_server.pointer := #REL (new_server_definition, new_application_file^);
      new_server_definition^ := converted_server_definition^;
      FREE converted_server_definition IN osv$task_private_heap^;
    IFEND;

  PROCEND move_server_definition;
?? TITLE := 'move_client_definition', EJECT ??

{ PURPOSE:
{ The purpose of this procedure is to move a client definition from the
{ old application definition file to the new application definition file.

  PROCEDURE move_client_definition
    (    old_client: nat$client_pointer;
     VAR new_client: nat$client_pointer;
     VAR old_application_file: ^SEQ ( * );
     VAR new_application_file: ^SEQ ( * ));

    VAR
      converted_client_definition: ^nat$complete_client_definition,
      new_client_definition: ^nat$complete_client_definition,
      old_client_definition: ^nat$complete_client_definition,
      old_file_header: ^nat$application_file_header;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;

    old_client_definition := #PTR (old_client.pointer, old_application_file^);
    IF (old_file_header^.version = nac$application_file_version) OR
          (old_file_header^.version = nac$v11_appl_file_version) THEN
      new_client.client := old_client.client;
      NEXT new_client_definition: [[REP #SIZE (old_client_definition^) OF cell]] IN new_application_file;
      new_client.pointer := #REL (new_client_definition, new_application_file^);
      new_client_definition^ := old_client_definition^;
    ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
      convert_v10_client_to_v11 (old_client_definition, converted_client_definition);
      new_client.client := old_client.client;
      NEXT new_client_definition: [[REP #SIZE (converted_client_definition^) OF cell]] IN
            new_application_file;
      new_client.pointer := #REL (new_client_definition, new_application_file^);
      new_client_definition^ := converted_client_definition^;
      FREE converted_client_definition IN osv$task_private_heap^;
    IFEND;

  PROCEND move_client_definition;
?? TITLE := 'move_tcpip_definition', EJECT ??

{ PURPOSE:
{ The purpose of this procedure is to move a tcpip definition from the
{ old application definition file to the new application definition file.

  PROCEDURE move_tcpip_definition
    (    old_tcpip: nat$tcpip_pointer;
     VAR new_tcpip: nat$tcpip_pointer;
     VAR old_application_file: ^SEQ ( * );
     VAR new_application_file: ^SEQ ( * ));

    VAR
      new_tcpip_definition: ^nat$complete_tcpip_definition,
      old_file_header: ^nat$application_file_header,
      old_tcpip_definition: ^nat$complete_tcpip_definition;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;

    old_tcpip_definition := #PTR (old_tcpip.pointer, old_application_file^);
    new_tcpip.application := old_tcpip.application;
    NEXT new_tcpip_definition: [[REP #SIZE (old_tcpip_definition^) OF cell]] IN new_application_file;
    new_tcpip.pointer := #REL (new_tcpip_definition, new_application_file^);
    new_tcpip_definition^ := old_tcpip_definition^;

  PROCEND move_tcpip_definition;
?? TITLE := 'open_cycle_1', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to define cycle 1 of the application file
{   and to open it for segment access.

  PROCEDURE open_cycle_1
    (VAR file_pointer: amt$segment_pointer;
     VAR file_id: amt$file_identifier;
     VAR status: ost$status);

    VAR
      ignore_status: ost$status,
      unique_name: ost$name;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    pmp$get_unique_name (unique_name, ignore_status);
    osp$establish_block_exit_hndlr (^handle_block_exit);
    pfp$begin_system_authority;
    pfp$define (unique_name, application_file_path, cycle_1, default_password, pfc$maximum_retention,
          pfc$no_log, status);
    IF status.normal THEN
      fsp$open_file (unique_name, amc$segment, ^access_selections, {default_creation_attributes =} NIL,
            {mandated_creation_attributes =} NIL, {attribute_validation =} NIL, {attribute_override =} NIL,
            file_id, status);
      IF status.normal THEN
        amp$get_segment_pointer (file_id, amc$sequence_pointer, file_pointer, status);
      ELSE
        amp$return (unique_name, ignore_status);
        pfp$purge (application_file_path, cycle_1, default_password, ignore_status);
      IFEND;
    IFEND;
    pfp$end_system_authority;
    osp$disestablish_cond_handler;

    IF NOT status.normal THEN
      nap$display_message (status);
    IFEND;

  PROCEND open_cycle_1;
?? TITLE := 'register_server_added_titles', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to register the titles in the server
{   added titles list.
{ NOTES:
{   It is assumed that the server attributes list is locked by the caller.

  PROCEDURE register_server_added_titles
    (VAR server_attributes: ^nat$server_attributes);

    VAR
      added_title: ^nat$added_title,
      domain: nat$title_domain,
      ignore_status: ost$status,
      protocol: nat$protocol,
      osi_address: nat$osi_registration_address,
      user_identifier: ost$name;

    domain.kind := nac$catenet_domain;
    protocol := server_attributes^.protocol;

    osi_address.kind := nac$osi_transport_address;
    osi_address.transport_selector := server_attributes^.application_id.osi_sap_identifier;

    added_title := server_attributes^.added_titles;
    user_identifier := server_attributes^.server;

    WHILE added_title <> NIL DO
      nlp$register_title (added_title^.title, osi_address, protocol, ^added_title^.data,
            added_title^.data_length, added_title^.priority, domain, added_title^.distribute_title,
            nac$cdna_external, default_directory_password, user_identifier, added_title^.identifier,
            ignore_status);
      added_title := added_title^.next_title;
    WHILEND;

  PROCEND register_server_added_titles;
?? TITLE := 'register_server_titles', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to register the titles in the server
{   titles list.
{ NOTES:
{   It is assumed that the server attributes list is locked by the caller.

  PROCEDURE register_server_titles
    (VAR server_attributes: ^nat$server_attributes;
     VAR status: ost$status);

    VAR
      domain: nat$title_domain,
      i: 1 .. 255,
      ignore_status: ost$status,
      protocol: nat$protocol,
      server_title: ^nat$server_title,
      osi_address: nat$osi_registration_address,
      user_identifier: ost$name;

    status.normal := TRUE;
    IF server_attributes^.server_titles <> NIL THEN
      osi_address.kind := nac$osi_transport_address;
      osi_address.transport_selector := server_attributes^.application_id.osi_sap_identifier;

      domain.kind := nac$catenet_domain;
      protocol := server_attributes^.protocol;
      user_identifier := server_attributes^.server;

    /selected_titles/
      FOR i := 1 TO UPPERBOUND (server_attributes^.server_titles^) DO
        server_title := ^server_attributes^.server_titles^ [i];
        nlp$register_title (server_title^.title, osi_address, protocol, ^server_title^.data,
              server_title^.data_length, server_title^.priority, domain, server_title^.distribute_title,
              nac$cdna_external, default_directory_password, user_identifier, server_title^.directory_id,
              status);
        IF NOT status.normal THEN
          EXIT /selected_titles/; {----->
        IFEND;
      FOREND /selected_titles/;
    IFEND;

  PROCEND register_server_titles;

?? TITLE := 'unassign_sap_identifier', EJECT ??

  PROCEDURE unassign_sap_identifier
    (    sap_identifier: nlt$ta_sap_selector);

    osp$set_job_signature_lock (nav$assigned_sap_list.lock);
    IF (sap_identifier >= LOWERBOUND (nav$assigned_sap_list.reserved_sap)) AND
          (sap_identifier <= UPPERBOUND (nav$assigned_sap_list.reserved_sap)) THEN
      nav$assigned_sap_list.reserved_sap [sap_identifier] := nac$unassigned;
    ELSEIF (sap_identifier >= LOWERBOUND (nav$assigned_sap_list.sap)) AND
          (sap_identifier <= UPPERBOUND (nav$assigned_sap_list.sap)) THEN
      nav$assigned_sap_list.sap [sap_identifier] := nac$unassigned;
    IFEND;
    osp$clear_job_signature_lock (nav$assigned_sap_list.lock);
  PROCEND unassign_sap_identifier;
?? TITLE := 'verify_appl_mgmt_capability', EJECT ??

  PROCEDURE verify_appl_mgmt_capability
    (VAR status: ost$status);

    VAR
      network_application_manager: boolean;

    status.normal := TRUE;
    IF NOT appl_mgmt_capability_verified THEN
      avp$get_capability (avc$network_applic_management, avc$user, appl_mgmt_capability_verified, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      IF NOT appl_mgmt_capability_verified THEN
        osp$set_status_abnormal (nac$status_id, nae$invalid_user, manage_network_applications, status);
      IFEND;
    IFEND;

  PROCEND verify_appl_mgmt_capability;
?? TITLE := '[XDCL, #GATE] nap$activate_client', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$activate_client
    (    client: nat$application_name;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$client_definition,
      complete_client_definition: ^nat$complete_client_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      v10_client_definition: ^nat$v10_client_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
      nap$find_client_attributes (client, client_attributes);
      IF client_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
      ELSE
        nlp$get_exclusive_access (client_attributes^.access_control);
        IF client_attributes^.client_status = nac$application_active THEN
          osp$set_status_abnormal (nac$status_id, nae$application_already_active, client, status);
        ELSEIF NOT highest_cycle_open THEN
          osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, activate_client#, status);
        ELSE
          RESET old_application_file;
          NEXT old_file_header IN old_application_file;
          find_client_definition (client, old_application_file, complete_client_definition);
          IF (complete_client_definition = NIL) THEN
            osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_client#, status);
          ELSE
            activate_client (client_attributes, status);
            IF status.normal THEN
              client_attributes^.client_status := nac$application_active;
              IF (old_file_header^.version = nac$application_file_version) OR
                    (old_file_header^.version = nac$v11_appl_file_version) THEN
                NEXT client_definition IN complete_client_definition;
                client_definition^.client_status := nac$application_active;
              ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
                NEXT v10_client_definition IN complete_client_definition;
                v10_client_definition^.client_status := nac$application_active;
              IFEND;
              pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);
              nav$appl_defn_time_stamp := old_file_header^.modification_date_time;
            IFEND;
          IFEND;
        IFEND;
        nlp$release_exclusive_access (client_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_client_definition (client, old_application_file, complete_client_definition);
      IF (complete_client_definition = NIL) THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_client#, status);
      ELSE
        IF (old_file_header^.version = nac$application_file_version) OR
              (old_file_header^.version = nac$v11_appl_file_version) THEN
          NEXT client_definition IN complete_client_definition;
          client_definition^.client_status := nac$application_active;
        ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
          NEXT v10_client_definition IN complete_client_definition;
          v10_client_definition^.client_status := nac$application_active;
        IFEND;
        pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);

        IF application_file_attached THEN
          nap$detach_application_file (local_status);
          IF (status.normal) AND (NOT local_status.normal) THEN
            status := local_status;
          ELSE
            nap$display_message (local_status);
          IFEND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$activate_client;
?? TITLE := '[XDCL, #GATE] nap$activate_server', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$activate_server
    (    server: nat$application_name;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      complete_server_definition: ^nat$complete_server_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      server_definition: ^nat$server_definition,
      server_attributes: ^nat$server_attributes,
      v10_server_definition: ^nat$v10_server_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (server, server_attributes);
      IF server_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSE
        nlp$get_exclusive_access (server_attributes^.access_control);
        IF server_attributes^.server_status = nac$application_active THEN
          osp$set_status_abnormal (nac$status_id, nae$application_already_active, server, status);
        ELSEIF NOT highest_cycle_open THEN
          osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, activate_server#, status);
        ELSE
          RESET old_application_file;
          NEXT old_file_header IN old_application_file;
          find_server_definition (server, old_application_file, complete_server_definition);
          IF (complete_server_definition = NIL) THEN
            osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_server#, status);
          ELSEIF (server_attributes^.nam_initiated_server) THEN
            activate_server (server_attributes, status);
          IFEND;
          IF status.normal THEN
            server_attributes^.server_status := nac$application_active;
            IF (old_file_header^.version = nac$application_file_version) OR
                  (old_file_header^.version = nac$v11_appl_file_version) THEN
              NEXT server_definition IN complete_server_definition;
              server_definition^.server_status := nac$application_active;
            ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
              NEXT v10_server_definition IN complete_server_definition;
              v10_server_definition^.server_status := nac$application_active;
            IFEND;
            pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);
            nav$appl_defn_time_stamp := old_file_header^.modification_date_time;
          IFEND;
        IFEND;
        nlp$release_exclusive_access (server_attributes^.access_control);
      IFEND;

      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_server_definition (server, old_application_file, complete_server_definition);
      IF (complete_server_definition = NIL) THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_server#, status);
      ELSE
        IF (old_file_header^.version = nac$application_file_version) OR
              (old_file_header^.version = nac$v11_appl_file_version) THEN
          NEXT server_definition IN complete_server_definition;
          server_definition^.server_status := nac$application_active;
        ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
          NEXT v10_server_definition IN complete_server_definition;
          v10_server_definition^.server_status := nac$application_active;
        IFEND;
        pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$activate_server;
?? TITLE := '[XDCL, #GATE] nap$activate_tcpip', EJECT ??
*copyc nah$activate_tcpip

  PROCEDURE [XDCL, #GATE] nap$activate_tcpip
    (    application: nat$application_name;
     VAR status: ost$status);


    VAR
      application_file_attached: boolean,
      complete_tcpip_definition: ^nat$complete_tcpip_definition,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcpip_definition: ^nat$tcpip_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      nap$find_tcpip_attributes (application, tcpip_attributes);
      IF tcpip_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSE { Application name valid.
        nlp$get_exclusive_access (tcpip_attributes^.access_control);
        IF tcpip_attributes^.tcpip_status = nac$application_active THEN
          osp$set_status_abnormal (nac$status_id, nae$application_already_active, application, status);
        ELSEIF NOT highest_cycle_open THEN
          osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, activate_tcpip#, status);
        ELSE
          RESET old_application_file;
          NEXT old_file_header IN old_application_file;
          find_tcpip_definition (application, old_application_file, complete_tcpip_definition);
          IF (complete_tcpip_definition = NIL) THEN
            osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_tcpip#, status);
          ELSE
            tcpip_attributes^.tcpip_status := nac$application_active;
            NEXT tcpip_definition IN complete_tcpip_definition;
            tcpip_definition^.tcpip_status := nac$application_active;
            pmp$get_compact_date_time (old_file_header^.modification_date_time, local_status);
            nav$appl_defn_time_stamp := old_file_header^.modification_date_time;
          IFEND;
        IFEND;
        nlp$release_exclusive_access (tcpip_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE { NAMVE not active.
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_tcpip_definition (application, old_application_file, complete_tcpip_definition);
      IF (complete_tcpip_definition = NIL) THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSE
        NEXT tcpip_definition IN complete_tcpip_definition;
        tcpip_definition^.tcpip_status := nac$application_active;
        pmp$get_compact_date_time (old_file_header^.modification_date_time, local_status);

        IF application_file_attached THEN
          nap$detach_application_file (local_status);
          IF (status.normal) AND (NOT local_status.normal) THEN
            status := local_status;
          ELSE
            nap$display_message (local_status);
          IFEND;
        IFEND;
      IFEND;
    IFEND;
  PROCEND nap$activate_tcpip;
?? TITLE := '[XDCL, #GATE] nap$add_server_title', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$add_server_title
    (    server: nat$application_name;
         title: nat$title;
         attributes: ^nat$title_attributes;
         broadcast_registration: boolean;
     VAR status: ost$status);

*copyc nah$add_server_title

    VAR
      added_title: ^nat$added_title,
      authorized_title: boolean,
      domain: nat$title_domain,
      i: integer,
      priority: nat$directory_priority,
      server_attributes: ^nat$server_attributes,
      user_identifier: ost$name,
      user_information: ^cell,
      user_information_length: 0 .. nac$max_directory_data_length,
      user_supplied_name: jmt$user_supplied_name,
      osi_address: nat$osi_registration_address;

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

    status.normal := TRUE;

    domain.kind := nac$catenet_domain;
    priority := nac$max_directory_priority;
    user_information_length := 0;
    user_information := NIL;
    IF STRLENGTH (title) < 1 THEN
      osp$set_status_abnormal (nac$status_id, nae$title_too_short, add_server_title, status);
    ELSEIF STRLENGTH (title) > nac$max_title_length THEN
      osp$set_status_abnormal (nac$status_id, nae$title_too_long, add_server_title, status);
      osp$append_status_integer (osc$status_parameter_delimiter, STRLENGTH (title), 10, FALSE, status);
    ELSEIF attributes <> NIL THEN
      FOR i := LOWERBOUND (attributes^) TO UPPERBOUND (attributes^) DO
        CASE attributes^ [i].selector OF
        = nac$title_priority =
          IF (attributes^ [i].priority >= nac$max_directory_priority) AND
                (attributes^ [i].priority <= nac$min_directory_priority) THEN
            priority := attributes^ [i].priority;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$invalid_directory_priority, add_server_title, status);
            osp$append_status_integer (osc$status_parameter_delimiter, attributes^ [i].priority, 10, FALSE,
                  status);
          IFEND;
        = nac$title_data =
          IF #SIZE (attributes^ [i].data^) <= nac$max_directory_data_length THEN
            user_information_length := #SIZE (attributes^ [i].data^);
            user_information := attributes^ [i].data;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$directory_data_too_large, add_server_title, status);
          IFEND;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$invalid_selector, add_server_title, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, attributes_parameter, status);
          osp$append_status_integer (osc$status_parameter_delimiter, i, 10, FALSE, status);
        CASEND;
      FOREND;
    IFEND;

    IF status.normal THEN
      osp$begin_subsystem_activity;
      REPEAT
        ALLOCATE added_title: [STRLENGTH (title)] IN nav$network_paged_heap^;
        IF added_title = NIL THEN
          osp$end_subsystem_activity;
          syp$cycle;
          osp$begin_subsystem_activity;
        IFEND;
      UNTIL added_title <> NIL;
      osp$push_inhibit_job_recovery;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (server, server_attributes);
      IF server_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSE
        nlp$get_exclusive_access (server_attributes^.access_control);
        nap$validate_user (server_attributes^.server_capability, server_attributes^.server_ring,
              server_attributes^.server_system_privilege, status);
        IF NOT status.normal THEN
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
        ELSEIF server_attributes^.server_status = nac$application_inactive THEN
          osp$set_status_abnormal (nac$status_id, nae$application_inactive, server, status);
        ELSEIF (NOT server_attributes^.nam_initiated_server) AND
              (NOT server_attributes^.protocol_activated) THEN
          osp$set_status_abnormal (nac$status_id, nae$no_server_job_attached, server, status);
        ELSE
          authorized_title := FALSE;
          IF server_attributes^.server_managed_titles <> NIL THEN

          /validate_title/
            FOR i := LOWERBOUND (server_attributes^.server_managed_titles^)
                  TO UPPERBOUND (server_attributes^.server_managed_titles^) DO
              IF nlp$name_match (server_attributes^.server_managed_titles^ [i], title) THEN
                authorized_title := TRUE;
                EXIT /validate_title/; {----->
              IFEND;
            FOREND /validate_title/;
          IFEND;
          IF authorized_title THEN
            osi_address.kind := nac$osi_transport_address;
            osi_address.transport_selector := server_attributes^.application_id.osi_sap_identifier;

            added_title^.title := title;
            user_identifier := server_attributes^.server;
            nlp$register_title (title, osi_address, server_attributes^.protocol, user_information,
                  user_information_length, priority, domain, broadcast_registration, nac$cdna_external,
                  default_directory_password, user_identifier, added_title^.identifier, status);
            IF status.normal THEN
              IF user_information <> NIL THEN
                i#move (user_information, ^added_title^.data, user_information_length);
              IFEND;
              added_title^.data_length := user_information_length;
              added_title^.distribute_title := broadcast_registration;
              added_title^.priority := priority;
              added_title^.next_title := server_attributes^.added_titles;
              server_attributes^.added_titles := added_title;
            ELSEIF status.condition = nae$duplicate_registration THEN
              osp$set_status_abnormal (nac$status_id, nae$duplicate_title, add_server_title, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, title, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, server, status);
            IFEND;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$title_not_authorized, add_server_title, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, title, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, server, status);
          IFEND;
        IFEND;
        nlp$release_exclusive_access (server_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      osp$pop_inhibit_job_recovery;
      IF NOT status.normal THEN
        FREE added_title IN nav$network_paged_heap^;
      IFEND;
      osp$end_subsystem_activity;
    IFEND;

  PROCEND nap$add_server_title;
?? TITLE := '[XDCL, #GATE] nap$attach_application_file', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to attach the application definition file
{   for exclusive access. If the file or the application subcatalog does not
{   exist, they are created here.

  PROCEDURE [XDCL, #GATE] nap$attach_application_file
    (VAR status: ost$status);

    VAR
      cycle_number: fst$cycle_number,
      display_status: ost$status,
      file_header: ^nat$application_file_header,
      ignore_status: ost$status,
      segment_pointer: amt$segment_pointer,
      share_selections: [STATIC, READ, oss$job_paged_literal] pft$share_selections := [],
      unique_name: ost$name,
      usage_selections: [STATIC, READ, oss$job_paged_literal] pft$usage_selections :=
            [pfc$read, pfc$shorten, pfc$append, pfc$modify];

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

{ Purge cycle 1 of the application file if it is the only cycle of the file and
{ display a warning message to the $RESPONSE file that the previous update
{ attempt failed.

    find_highest_cycle_number (application_file_path, cycle_number, status);
    IF status.normal THEN
      IF cycle_number = pfc$minimum_cycle_number THEN
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        pfp$purge (application_file_path, cycle_1, default_password, ignore_status);
        pfp$end_system_authority;
        osp$disestablish_cond_handler;
        osp$set_status_condition (nae$cycle_1_present, display_status);
        display_message_to_$response (display_status, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;
    IFEND;
    status.normal := TRUE;

{ Attach highest cycle of the application file.

    pmp$get_unique_name (unique_name, ignore_status);
    osp$establish_block_exit_hndlr (^handle_block_exit);
    pfp$begin_system_authority;
    pfp$attach (unique_name, application_file_path, highest_cycle, default_password, usage_selections,
          share_selections, pfc$no_wait, status);
    pfp$end_system_authority;
    osp$disestablish_cond_handler;
    IF NOT status.normal THEN
      IF (status.condition <> pfe$unknown_permanent_file) AND
            (status.condition <> pfe$unknown_last_subcatalog) THEN
        nap$display_message (status);
        RETURN; {----->
      IFEND;

      IF status.condition = pfe$unknown_last_subcatalog THEN
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        pfp$define_catalog (application_catalog, status);
        pfp$end_system_authority;
        osp$disestablish_cond_handler;
        IF NOT status.normal THEN
          nap$display_message (status);
          RETURN; {----->
        IFEND;
      IFEND;

{ Define the application definition file.

      osp$establish_block_exit_hndlr (^handle_block_exit);
      pfp$begin_system_authority;
      pfp$define (unique_name, application_file_path, cycle_2, default_password, pfc$maximum_retention,
            pfc$no_log, status);
      pfp$end_system_authority;
      osp$disestablish_cond_handler;
      IF NOT status.normal THEN
        nap$display_message (status);
        RETURN; {----->
      IFEND;

{ Open the file and initialize the header.

      fsp$open_file (unique_name, amc$segment, ^access_selections, {default_creation_attributes =} NIL,
            {mandated_creation_attributes =} NIL, {attribute_validation =} NIL, {attribute_override =} NIL,
            highest_cycle_id, status);
      IF NOT status.normal THEN
        nap$display_message (status);
        amp$return (unique_name, ignore_status);
        RETURN; {----->
      IFEND;

      amp$get_segment_pointer (highest_cycle_id, amc$sequence_pointer, segment_pointer, status);
      IF NOT status.normal THEN
        nap$display_message (status);
        fsp$close_file (highest_cycle_id, ignore_status);
        amp$return (unique_name, ignore_status);
        RETURN; {----->
      IFEND;

      old_application_file := segment_pointer.sequence_pointer;
      RESET old_application_file;
      NEXT file_header IN old_application_file;
      file_header^.version := nac$application_file_version;
      pmp$get_compact_date_time (file_header^.creation_date_time, ignore_status);
      file_header^.modification_date_time := file_header^.creation_date_time;
      file_header^.server_count := 0;
      file_header^.client_count := 0;
      file_header^.tcpip_count := 0;
      segment_pointer.sequence_pointer := old_application_file;
      amp$set_segment_eoi (highest_cycle_id, segment_pointer, status);
      RESET old_application_file;
      highest_cycle_open := TRUE;
    ELSE
      fsp$open_file (unique_name, amc$segment, ^access_selections, {default_creation_attributes =} NIL,
            {mandated_creation_attributes =} NIL, {attribute_validation =} NIL, {attribute_override =} NIL,
            highest_cycle_id, status);
      IF status.normal THEN
        amp$get_segment_pointer (highest_cycle_id, amc$sequence_pointer, segment_pointer, status);
        IF status.normal THEN
          old_application_file := segment_pointer.sequence_pointer;
          RESET old_application_file;

{ Verify that the header is present.

          NEXT file_header IN old_application_file;
          IF (file_header = NIL) OR ((file_header^.version <> nac$application_file_version) AND
                (file_header^.version <> nac$v11_appl_file_version) AND
                (file_header^.version <> nac$v10_appl_file_version)) THEN
            osp$set_status_abnormal (nac$status_id, nae$application_file_error, attach_application_file,
                  status);
          ELSEIF (nav$applications_installed) AND (file_header^.modification_date_time <>
                nav$appl_defn_time_stamp) THEN
            osp$set_status_condition (nae$application_file_mismatch, status);
          IFEND;
        IFEND;

        IF NOT status.normal THEN
          fsp$close_file (highest_cycle_id, ignore_status);
          amp$return (unique_name, ignore_status);
        IFEND;

        highest_cycle_open := status.normal;
      ELSE
        nap$display_message (status);
        amp$return (unique_name, ignore_status);
      IFEND;

    IFEND;

{ If cycle 1 of the application file exists, purge the file and display a
{ warning message to the $RESPONSE file that the previous update attempt failed.

    IF cycle_number <> pfc$minimum_cycle_number THEN
      pmp$get_unique_name (unique_name, ignore_status);
      osp$establish_block_exit_hndlr (^handle_block_exit);
      pfp$begin_system_authority;
      pfp$attach (unique_name, application_file_path, cycle_1, default_password, usage_selections,
            share_selections, pfc$no_wait, status);
      IF (status.normal) OR ((NOT status.normal) AND (status.condition = pfe$cycle_busy)) THEN
        amp$return (unique_name, ignore_status);
        pfp$purge (application_file_path, cycle_1, default_password, ignore_status);
        osp$set_status_condition (nae$cycle_1_present, display_status);
        display_message_to_$response (display_status, status);
        IF NOT status.normal THEN
          pfp$end_system_authority;
          osp$disestablish_cond_handler;
          RETURN; {----->
        IFEND;
      IFEND;
      pfp$end_system_authority;
      osp$disestablish_cond_handler;
      status.normal := TRUE;
    IFEND;

  PROCEND nap$attach_application_file;
?? TITLE := '[XDCL, #GATE] nap$attach_server_application ', EJECT ??
*copyc nah$attach_server_application

  PROCEDURE [XDCL, #GATE] nap$attach_server_application
    (    server: nat$application_name;
         max_connections: nat$number_of_connections;
     VAR status: ost$status);

    VAR
      job_name: jmt$system_supplied_name,
      ignore_status: ost$status,
      user_supplied_name: jmt$user_supplied_name;

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

    status.normal := TRUE;
    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);

    pmp$get_job_names (user_supplied_name, job_name, ignore_status);
    attach_server_application (job_name, server, max_connections, status);

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$attach_server_application;
?? TITLE := '[XDCL, #GATE] nap$attach_specific_server_appl', EJECT ??

{ PURPOSE:
{   The purpose of this request is to attach the specified server application.  The
{   request is the same as nap$attach_server_application except that the job name is
{   a parameter on this request.

  PROCEDURE [XDCL, #GATE] nap$attach_specific_server_appl
    (    system_job_name: jmt$system_supplied_name;
         server: nat$application_name;
         max_connections: nat$number_of_connections;
     VAR status: ost$status);


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

    status.normal := TRUE;
    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);

    attach_server_application (system_job_name, server, max_connections, status);

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$attach_specific_server_appl;
?? TITLE := '[XDCL, #GATE] nap$change_client', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$change_client
    (    client: nat$application_name;
         max_connections: nat$number_of_connections;
         connection_priority: nat$network_message_priority;
         reserved_application_id: boolean;
         application_id: nat$internet_sap_identifier;
         client_capability: ost$name;
         client_ring: ost$ring;
         client_system_privilege: boolean;
     VAR status: ost$status);

    VAR
      converted_client_definition: ^nat$complete_client_definition,
      i: 1 .. 65535,
      j: 1 .. 65535,
      ignore_status: ost$status,
      modification_date_time: ost$date_time,
      new_application_file: ^SEQ ( * ),
      new_client_attributes: ^nat$client_attributes,
      new_client_definition: ^nat$client_definition,
      new_client_pointers: ^nat$client_pointers,
      new_complete_client_definition: ^nat$complete_client_definition,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_attributes: ^nat$client_attributes,
      old_client_definition: ^nat$client_definition,
      old_client_pointers: ^nat$client_pointers,
      old_complete_client_definition: ^nat$complete_client_definition,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      sap_changed: boolean,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF NOT (highest_cycle_open) THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, change_client, status);
      RETURN; {----->
    IFEND;

    open_cycle_1 (new_file_pointer, new_file_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;
    new_application_file := new_file_pointer.sequence_pointer;
    RESET new_application_file;
    NEXT new_file_header IN new_application_file;
    IF old_file_header^.version = nac$application_file_version THEN
      new_file_header^ := old_file_header^;
    ELSE
      RESET old_application_file;
      NEXT v10_v11_file_header IN old_application_file;
      new_file_header^.version := nac$application_file_version;
      new_file_header^.creation_date_time := old_file_header^.creation_date_time;
      new_file_header^.server_count := old_file_header^.server_count;
      new_file_header^.client_count := old_file_header^.client_count;
      new_file_header^.tcpip_count := 0;
    IFEND;
    pmp$get_compact_date_time (modification_date_time, ignore_status);
    new_file_header^.modification_date_time := modification_date_time;

    IF old_file_header^.server_count > 0 THEN
      NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
      NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
    IFEND;

    IF old_file_header^.client_count > 0 THEN
      NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
      NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
    IFEND;

    IF new_file_header^.tcpip_count > 0 THEN
      NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
      NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
    IFEND;

{ Move server definitions to the new application file.

    FOR i := 1 TO old_file_header^.server_count DO
      move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

    NEXT new_complete_client_definition: [[nat$client_definition]] IN new_application_file;
    RESET new_complete_client_definition;
    NEXT new_client_definition IN new_complete_client_definition;

{ Find the old definition of the client and move it to the new application
{ file.

    find_client_definition (client, old_application_file, old_complete_client_definition);
    IF old_complete_client_definition = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_error, change_client, status);
      close_cycle_1 (new_file_id);
      RETURN; {----->
    IFEND;
    IF (old_file_header^.version = nac$application_file_version) OR
          (old_file_header^.version = nac$v11_appl_file_version) THEN
      NEXT old_client_definition IN old_complete_client_definition;
      new_client_definition^ := old_client_definition^;
    ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
      convert_v10_client_to_v11 (old_complete_client_definition, converted_client_definition);
      RESET converted_client_definition;
      NEXT old_client_definition IN converted_client_definition;
      new_client_definition^ := old_client_definition^;
      FREE converted_client_definition IN osv$task_private_heap^;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
            status);
      close_cycle_1 (new_file_id);
      RETURN; {----->
    IFEND;

{  Set the new attribute values into the client definition.

    new_client_definition^.max_connections := max_connections;
    new_client_definition^.client_capability := client_capability;
    new_client_definition^.client_ring := client_ring;
    new_client_definition^.client_system_privilege := client_system_privilege;
    new_client_definition^.message_priority := connection_priority;
    new_client_definition^.reserved_application_id := reserved_application_id;
    IF reserved_application_id THEN
      new_client_definition^.application_id := application_id;
    IFEND;

{  Setup relative pointers to the new client definition.

    new_client_pointers^ [1].client := client;
    new_client_pointers^ [1].pointer := #REL (new_complete_client_definition, new_application_file^);

{ Move the remaining client definitions to the new application file.

    j := 1;
    FOR i := 1 TO old_file_header^.client_count DO
      IF old_client_pointers^ [i].client <> client THEN
        j := j + 1;
        move_client_definition (old_client_pointers^ [i], new_client_pointers^ [j], old_application_file,
              new_application_file);
      IFEND;
    FOREND;

{ Move tcpip definitions to the new application file.

    FOR i := 1 TO new_file_header^.tcpip_count DO
      move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

    IF nav$namve_active THEN

{ Move the client's old attributes to a local storage area and then change the
{ old attributes to their new values.

      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
      nap$find_client_attributes (client, old_client_attributes);
      IF old_client_attributes = NIL THEN
        osp$set_status_condition (nae$application_file_mismatch, status);
        nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
        osp$end_subsystem_activity;
        osp$pop_inhibit_job_recovery;
        close_cycle_1 (new_file_id);
        RETURN; {----->
      IFEND;
      PUSH new_client_attributes;
      nlp$get_exclusive_access (old_client_attributes^.access_control);
      new_client_attributes^ := old_client_attributes^;

      new_client_attributes^.client_capability := new_client_definition^.client_capability;
      new_client_attributes^.client_ring := new_client_definition^.client_ring;
      new_client_attributes^.client_system_privilege := new_client_definition^.client_system_privilege;
      new_client_attributes^.max_connections := new_client_definition^.max_connections;
      new_client_attributes^.message_priority := new_client_definition^.message_priority;
      new_client_attributes^.flags.nam_accounting := new_client_definition^.flags.nam_accounting;
      new_client_attributes^.reserved_application_id := new_client_definition^.reserved_application_id;
      IF new_client_attributes^.reserved_application_id THEN
        new_client_attributes^.application_id.xns_sap_identifier := new_client_definition^.application_id;
        new_client_attributes^.application_id.osi_sap_identifier :=
              (new_client_definition^.application_id - minimum_xns_sap_identifier) +
              nlc$ta_min_rsvd_se_session_sap;
      ELSEIF old_client_attributes^.reserved_application_id THEN
        new_client_attributes^.application_id.xns_sap_identifier := 0;
        new_client_attributes^.application_id.osi_sap_identifier := 0;
      IFEND;

{ Change the client's sap if the client's application identifier changed,
{ connection priority changed or max connections were increased.

      sap_changed := FALSE;
      IF old_client_attributes^.sap_open THEN
        IF (new_client_attributes^.application_id <> old_client_attributes^.application_id) OR
              (new_client_attributes^.message_priority <> old_client_attributes^.message_priority) OR
              (new_client_attributes^.max_connections > old_client_attributes^.max_connections) THEN
          nlp$se_close_sap (old_client_attributes^.application_id, status);
          nap$display_message (status);

{ Unassign the old sap in case both the old sap and new sap are the same reserved value but
{ with different priorities.

          unassign_sap_identifier (old_client_attributes^.application_id.osi_sap_identifier);
          old_client_attributes^.sap_open := FALSE;
          new_client_attributes^.sap_open := FALSE;
          assign_sap_identifier (new_client_attributes^.reserved_application_id,
                new_client_attributes^.application_id.osi_sap_identifier, status);
          IF status.normal THEN
            nlp$se_open_sap (nac$nil, FALSE, new_client_attributes^.max_connections, status);
            IF status.normal THEN
              new_client_attributes^.sap_open := TRUE;
              sap_changed := TRUE;
            ELSE
              unassign_sap_identifier (new_client_attributes^.application_id.osi_sap_identifier);
            IFEND;
          IFEND;
          IF NOT status.normal THEN
{ Error encountered while changing the client; restore the client sap.

            nap$display_message (status);
            assign_sap_identifier (old_client_attributes^.reserved_application_id,
                  old_client_attributes^.application_id.osi_sap_identifier, status);
            IF status.normal THEN
              nlp$se_open_sap (nac$nil, FALSE, old_client_attributes^.max_connections, status);
              IF status.normal THEN
                old_client_attributes^.sap_open := TRUE;
              ELSE
                unassign_sap_identifier (old_client_attributes^.application_id.osi_sap_identifier);
                nap$display_message (status);
                osp$set_status_abnormal (nac$status_id, nae$application_not_restored, client, status);
                old_client_attributes^.client_status := nac$application_inactive;
              IFEND;
            ELSE
              nap$display_message (status);
              osp$set_status_abnormal (nac$status_id, nae$application_not_restored, client, status);
              old_client_attributes^.client_status := nac$application_inactive;
            IFEND;
            nlp$release_exclusive_access (old_client_attributes^.access_control);
            nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
            osp$end_subsystem_activity;
            osp$pop_inhibit_job_recovery;
            close_cycle_1 (new_file_id);
            RETURN; {----->
          IFEND;
        IFEND;
      IFEND;

{ Change application definition file cycle 1 to new highest cycle.

      new_file_pointer.sequence_pointer := new_application_file;
      close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
      IF status.normal THEN

{ Change the client attributes entry to have the new attribute values.

        old_client_attributes^ := new_client_attributes^;
        nav$appl_defn_time_stamp := modification_date_time;
      ELSE

{ Error encountered while changing the client; restore the client sap.

        nap$display_message (status);
        IF sap_changed THEN
          nlp$se_close_sap (new_client_attributes^.application_id, status);
          unassign_sap_identifier (new_client_attributes^.application_id.osi_sap_identifier);
          assign_sap_identifier (old_client_attributes^.reserved_application_id,
                old_client_attributes^.application_id.osi_sap_identifier, status);
          IF status.normal THEN
            nlp$se_open_sap (nac$nil, FALSE, old_client_attributes^.max_connections, status);
            IF status.normal THEN
              old_client_attributes^.sap_open := TRUE;
            ELSE
              unassign_sap_identifier (old_client_attributes^.application_id.osi_sap_identifier);
            IFEND;
          IFEND;
          IF NOT status.normal THEN
            nap$display_message (status);
            osp$set_status_abnormal (nac$status_id, nae$application_not_restored, client, status);
            old_client_attributes^.client_status := nac$application_inactive;
          IFEND;
        IFEND;
      IFEND;

      nlp$release_exclusive_access (old_client_attributes^.access_control);
      nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;

    ELSE

{ NAMVE is not active.  Change the application definition file cycle 1
{ to new highest cycle.

      new_file_pointer.sequence_pointer := new_application_file;
      close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
    IFEND;

  PROCEND nap$change_client;
?? TITLE := '[XDCL, #GATE] nap$change_server', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$change_server
    (    server: nat$application_name;
         selected_titles_changed: boolean;
         selected_titles: ^nat$selected_titles_list;
         server_managed_titles: ^nat$title_pattern_list;
         max_connections: nat$number_of_connections;
         connection_priority: nat$network_message_priority;
         server_capability: ost$name;
         server_ring: ost$ring;
         server_system_privilege: boolean;
         accept_connection: boolean;
         client_validation_capability: ost$name;
         client_info_source: nat$client_info_source;
         client_addresses: ^array [1 .. * ] of nat$client_address,
         reserved_application_id: boolean;
         application_id: nat$internet_sap_identifier;
         server_job_changed: boolean;
         server_job: amt$local_file_name;
         server_job_validation_source: nat$server_validation_source,
         server_job_max_connections: nat$number_of_connections;
     VAR status: ost$status);

    VAR
      actual_max_connections: nat$number_of_connections,
      binary_mainframe_id: pmt$binary_mainframe_id,
      converted_server_definition: ^nat$complete_server_definition,
      device_assigned: boolean,
      device_class: rmt$device_class,
      domain: nat$title_domain,
      free_added_titles: boolean,
      i: 1 .. 65535,
      j: 1 .. 65535,
      ignore_status: ost$status,
      modification_date_time: ost$date_time,
      nam_initiated_server: boolean,
      new_application_file: ^SEQ ( * ),
      new_client_addresses: ^array [1 .. * ] of nat$client_address,
      new_client_pointers: ^nat$client_pointers,
      new_complete_server_definition: ^nat$complete_server_definition,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_patterns_list: ^nat$title_pattern_list,
      new_titles_list: ^nat$selected_titles_list,
      new_selected_titles: ^nat$selected_titles_list,
      new_selected_titles_count: integer,
      new_server_attributes: ^nat$server_attributes,
      new_server_definition: ^nat$server_definition,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_pointers: ^nat$client_pointers,
      old_complete_server_definition: ^nat$complete_server_definition,
      old_file_header: ^nat$application_file_header,
      old_server_attributes: ^nat$server_attributes,
      old_server_definition: ^nat$server_definition,
      old_server_pointers: ^nat$server_pointers,
      old_service_file_defined: boolean,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      osi_address: nat$osi_registration_address,
      protocol: nat$protocol,
      purge_server_file: boolean,
      register_titles: boolean,
      sap_changed: boolean,
      server_definition_file: array [1 .. 6] of pft$name,
      server_title: ^nat$server_title,
      size_of_client_addresses: integer,
      size_of_selected_titles: integer,
      size_of_server_managed_titles: integer,
      timesharing_title: ost$name,
      title_count: integer,
      user_identifier: ost$name,
      v10_v11_file_header: ^nat$v10_v11_file_header;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF NOT (highest_cycle_open) THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, change_server, status);
      RETURN; {----->
    IFEND;

    open_cycle_1 (new_file_pointer, new_file_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;
    new_application_file := new_file_pointer.sequence_pointer;
    RESET new_application_file;
    NEXT new_file_header IN new_application_file;

    IF old_file_header^.version = nac$application_file_version THEN
      new_file_header^ := old_file_header^;
    ELSE
      RESET old_application_file;
      NEXT v10_v11_file_header IN old_application_file;
      new_file_header^.version := nac$application_file_version;
      new_file_header^.creation_date_time := old_file_header^.creation_date_time;
      new_file_header^.server_count := old_file_header^.server_count;
      new_file_header^.client_count := old_file_header^.client_count;
      new_file_header^.tcpip_count := 0;
    IFEND;
    pmp$get_compact_date_time (modification_date_time, ignore_status);
    new_file_header^.modification_date_time := modification_date_time;

    IF old_file_header^.server_count > 0 THEN
      NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
      NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
    IFEND;

    IF old_file_header^.client_count > 0 THEN
      NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
      NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
    IFEND;

    IF new_file_header^.tcpip_count > 0 THEN
      NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
      NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
    IFEND;

    IF selected_titles <> NIL THEN
      IF server = osc$timesharing THEN
        pmp$get_pseudo_mainframe_id (binary_mainframe_id);
        jmp$generate_timesharing_title (binary_mainframe_id, timesharing_title);
        new_selected_titles_count := 0;
        FOR i := 1 TO UPPERBOUND (selected_titles^) DO
          IF selected_titles^ [i].title <> timesharing_title THEN
            new_selected_titles_count := new_selected_titles_count + 1;
          IFEND;
        FOREND;

{ Delete the remote attach job timesharing title from the list.

        IF new_selected_titles_count < UPPERBOUND (selected_titles^) THEN
          PUSH new_selected_titles: [1 .. new_selected_titles_count];
          j := 1;
          FOR i := 1 TO UPPERBOUND (selected_titles^) DO
            IF selected_titles^ [i].title <> timesharing_title THEN
              new_selected_titles^ [j] := selected_titles^ [i];
              j := j + 1;
            IFEND;
          FOREND;
          size_of_selected_titles := #SIZE (new_selected_titles^);
        ELSE
          size_of_selected_titles := #SIZE (selected_titles^);
          new_selected_titles := selected_titles;
        IFEND;
      ELSE
        size_of_selected_titles := #SIZE (selected_titles^);
        new_selected_titles := selected_titles;
      IFEND;
    ELSE
      size_of_selected_titles := 0;
      new_selected_titles := NIL;
    IFEND;

    IF server_managed_titles <> NIL THEN
      size_of_server_managed_titles := #SIZE (server_managed_titles^);
    ELSE
      size_of_server_managed_titles := 0;
    IFEND;

    IF client_addresses <> NIL THEN
      size_of_client_addresses := #SIZE (client_addresses^);
    ELSE
      size_of_client_addresses := 0;
    IFEND;

    NEXT new_complete_server_definition: [[REP (#SIZE (nat$server_definition) + size_of_selected_titles +
          size_of_server_managed_titles + size_of_client_addresses) OF cell]] IN new_application_file;
    RESET new_complete_server_definition;
    NEXT new_server_definition IN new_complete_server_definition;

{ Find the old definition of the server and move it to the new application
{ file.

    find_server_definition (server, old_application_file, old_complete_server_definition);
    IF old_complete_server_definition = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_error, change_server, status);
      close_cycle_1 (new_file_id);
      RETURN; {----->
    IFEND;
    IF (old_file_header^.version = nac$application_file_version) OR
          (old_file_header^.version = nac$v11_appl_file_version) THEN
      NEXT old_server_definition IN old_complete_server_definition;
      new_server_definition^ := old_server_definition^;
    ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
      convert_v10_server_to_v11 (old_complete_server_definition, converted_server_definition);
      RESET converted_server_definition;
      NEXT old_server_definition IN converted_server_definition;
      new_server_definition^ := old_server_definition^;
      FREE converted_server_definition IN osv$task_private_heap^;
    ELSE
      osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
            status);
      close_cycle_1 (new_file_id);
      RETURN; {----->
    IFEND;

{  Save some of the old attribute values before they are changed.

    nam_initiated_server := old_server_definition^.nam_initiated_server;
    old_service_file_defined := old_server_definition^.service_file_defined;

{ Check if server job file is valid.

    IF nam_initiated_server AND server_job_changed THEN
      rmp$get_device_class (server_job, device_assigned, device_class, status);
      IF (NOT status.normal) AND (device_class <> rmc$null_device) THEN
        nap$display_message (status);
        close_cycle_1 (new_file_id);
        RETURN; {----->
      IFEND;
    IFEND;

{ Determine the actual max connections for timesharing server.
    actual_max_connections := max_connections;

{  Set the new attribute values into the server definition.

    new_server_definition^.max_connections := actual_max_connections;
    IF new_selected_titles <> NIL THEN
      new_server_definition^.title_count := UPPERBOUND (new_selected_titles^);
    ELSE
      new_server_definition^.title_count := 0;
    IFEND;
    IF server_managed_titles <> NIL THEN
      new_server_definition^.server_managed_title_count := UPPERBOUND (server_managed_titles^);
    ELSE
      new_server_definition^.server_managed_title_count := 0;
    IFEND;
    new_server_definition^.server_capability := server_capability;
    new_server_definition^.server_ring := server_ring;
    new_server_definition^.server_system_privilege := server_system_privilege;
    new_server_definition^.accept_connection := accept_connection;
    new_server_definition^.client_validation_capability := client_validation_capability;
    new_server_definition^.client_info_source := client_info_source;
    IF client_addresses <> NIL THEN
      new_server_definition^.client_address_count := UPPERBOUND (client_addresses^);
    ELSE
      new_server_definition^.client_address_count := 0;
    IFEND;

    new_server_definition^.reserved_application_id := reserved_application_id;
    new_server_definition^.application_id := application_id;
    new_server_definition^.message_priority := connection_priority;
    IF nam_initiated_server THEN
      new_server_definition^.server_job_validation_source := server_job_validation_source;
      new_server_definition^.server_job_max_connections := server_job_max_connections;
      IF server_job_changed THEN
        new_server_definition^.service_file_defined := device_class <> rmc$null_device;
      IFEND;
    IFEND;

{ Setup the selected titles.

    IF new_server_definition^.title_count > 0 THEN
      NEXT new_titles_list: [1 .. new_server_definition^.title_count] IN new_complete_server_definition;
      new_titles_list^ := new_selected_titles^;
      new_server_definition^.selected_titles := #REL (new_titles_list, new_complete_server_definition^);
    IFEND;

{ Setup the server_managed titles.

    IF new_server_definition^.server_managed_title_count > 0 THEN
      NEXT new_patterns_list: [1 .. new_server_definition^.server_managed_title_count] IN
            new_complete_server_definition;
      new_patterns_list^ := server_managed_titles^;
      new_server_definition^.server_managed_titles := #REL (new_patterns_list,
            new_complete_server_definition^);
    IFEND;

{ Setup the client_addresses.

    IF new_server_definition^.client_address_count > 0 THEN
      NEXT new_client_addresses: [1 .. new_server_definition^.client_address_count] IN
            new_complete_server_definition;
      new_client_addresses^ := client_addresses^;
      new_server_definition^.client_addresses := #REL (new_client_addresses, new_complete_server_definition^);
    IFEND;

{ Setup the relative pointer to the new server definition.

    new_server_pointers^ [1].server := server;
    new_server_pointers^ [1].pointer := #REL (new_complete_server_definition, new_application_file^);

{ Move the remaining server and client definitions to the new application file.

    j := 1;
    FOR i := 1 TO old_file_header^.server_count DO
      IF old_server_pointers^ [i].server <> server THEN
        j := j + 1;
        move_server_definition (old_server_pointers^ [i], new_server_pointers^ [j], old_application_file,
              new_application_file);
      IFEND;
    FOREND;

    FOR i := 1 TO old_file_header^.client_count DO
      move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

{ Move tcpip definitions to the new application file.

    FOR i := 1 TO new_file_header^.tcpip_count DO
      move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

    IF nav$namve_active THEN

{ Move the server's old attributes to a local storage area and then change the
{ old attributes to their new values.

      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (server, old_server_attributes);
      IF old_server_attributes = NIL THEN
        osp$set_status_condition (nae$application_file_mismatch, status);
        nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
        osp$end_subsystem_activity;
        osp$pop_inhibit_job_recovery;
        close_cycle_1 (new_file_id);
        RETURN; {----->
      IFEND;
      PUSH new_server_attributes;
      nlp$get_exclusive_access (old_server_attributes^.access_control);
      new_server_attributes^ := old_server_attributes^;

      new_server_attributes^.accept_connection := new_server_definition^.accept_connection;
      new_server_attributes^.client_info_source := new_server_definition^.client_info_source;
      new_server_attributes^.client_validation_capability :=
            new_server_definition^.client_validation_capability;
      new_server_attributes^.flags.nam_accounting := new_server_definition^.flags.nam_accounting;
      new_server_attributes^.max_connections := new_server_definition^.max_connections;
      new_server_attributes^.message_priority := new_server_definition^.message_priority;
      new_server_attributes^.reserved_application_id := new_server_definition^.reserved_application_id;
      IF new_server_attributes^.reserved_application_id THEN
        new_server_attributes^.application_id.xns_sap_identifier := new_server_definition^.application_id;
        new_server_attributes^.application_id.osi_sap_identifier :=
              (new_server_definition^.application_id - minimum_xns_sap_identifier) +
              nlc$ta_min_rsvd_se_session_sap;
      ELSEIF old_server_attributes^.reserved_application_id THEN
        new_server_attributes^.application_id.xns_sap_identifier := 0;
        new_server_attributes^.application_id.osi_sap_identifier := 0;
      IFEND;
      new_server_attributes^.server_capability := new_server_definition^.server_capability;
      new_server_attributes^.server_ring := new_server_definition^.server_ring;
      new_server_attributes^.server_system_privilege := new_server_definition^.server_system_privilege;
      IF new_server_attributes^.nam_initiated_server THEN
        new_server_attributes^.service_file_defined := new_server_definition^.service_file_defined;
        new_server_attributes^.server_job_max_connections :=
              new_server_definition^.server_job_max_connections;
        new_server_attributes^.server_job_validation_source :=
              new_server_definition^.server_job_validation_source;
      IFEND;
      IF new_server_definition^.client_address_count > 0 THEN
        new_client_addresses := #PTR (new_server_definition^.client_addresses,
              new_complete_server_definition^);
        REPEAT
          ALLOCATE new_server_attributes^.client_addresses: [1 .. new_server_definition^.
                client_address_count] IN nav$network_paged_heap^;
          IF new_server_attributes^.client_addresses = NIL THEN
            osp$end_subsystem_activity;
            syp$cycle;
            osp$begin_subsystem_activity;
          IFEND;
        UNTIL new_server_attributes^.client_addresses <> NIL;
        new_server_attributes^.client_addresses^ := new_client_addresses^;
      ELSE
        new_server_attributes^.client_addresses := NIL;
      IFEND;

      IF selected_titles_changed THEN
        IF (new_server_definition^.title_count > 0) OR (new_server_definition^.server = osc$timesharing) THEN
          new_titles_list := #PTR (new_server_definition^.selected_titles, new_complete_server_definition^);
          IF new_server_definition^.server = osc$timesharing THEN
            title_count := new_server_definition^.title_count + 1;
          ELSE
            title_count := new_server_definition^.title_count;
          IFEND;
          REPEAT
            ALLOCATE new_server_attributes^.server_titles: [1 .. title_count] IN nav$network_paged_heap^;
            IF new_server_attributes^.server_titles = NIL THEN
              osp$end_subsystem_activity;
              syp$cycle;
              osp$begin_subsystem_activity;
            IFEND;
          UNTIL new_server_attributes^.server_titles <> NIL;
          FOR i := 1 TO new_server_definition^.title_count DO
            new_server_attributes^.server_titles^ [i].title := new_titles_list^ [i].title;
            new_server_attributes^.server_titles^ [i].distribute_title :=
                  new_titles_list^ [i].distribute_title;
            new_server_attributes^.server_titles^ [i].priority := new_titles_list^ [i].priority;
            new_server_attributes^.server_titles^ [i].data_length := new_titles_list^ [i].data_length;
            new_server_attributes^.server_titles^ [i].data := new_titles_list^ [i].data;
          FOREND;
          IF new_server_definition^.server = osc$timesharing THEN
            pmp$get_pseudo_mainframe_id (binary_mainframe_id);
            jmp$generate_timesharing_title (binary_mainframe_id, timesharing_title);
            new_server_attributes^.server_titles^ [title_count].title := timesharing_title;
            new_server_attributes^.server_titles^ [title_count].distribute_title := FALSE;
            new_server_attributes^.server_titles^ [title_count].priority := nac$max_directory_priority;
            new_server_attributes^.server_titles^ [title_count].data_length := 0;
          IFEND;
        ELSE
          new_server_attributes^.server_titles := NIL;
        IFEND;
      ELSE
        new_server_attributes^.server_titles := old_server_attributes^.server_titles;
      IFEND;

      IF new_server_definition^.server_managed_title_count > 0 THEN
        new_patterns_list := #PTR (new_server_definition^.server_managed_titles,
              new_complete_server_definition^);
        REPEAT
          ALLOCATE new_server_attributes^.server_managed_titles:
                [1 .. new_server_definition^.server_managed_title_count] IN nav$network_paged_heap^;
          IF new_server_attributes^.server_managed_titles = NIL THEN
            osp$end_subsystem_activity;
            syp$cycle;
            osp$begin_subsystem_activity;
          IFEND;
        UNTIL new_server_attributes^.server_managed_titles <> NIL;
        FOR i := 1 TO new_server_definition^.server_managed_title_count DO
          new_server_attributes^.server_managed_titles^ [i] := new_patterns_list^ [i];
        FOREND;
      ELSE
        new_server_attributes^.server_managed_titles := NIL;
      IFEND;

{ Change the server's sap if the server's application identifier changed, connection priority changed
{ or max connections were increased. Register the server titles if the titles
{ or server sap was changed and register the server managed titles if the
{ server sap was changed.

      register_titles := FALSE;
      sap_changed := FALSE;
      IF nam_initiated_server OR (NOT nam_initiated_server AND new_server_attributes^.protocol_activated) THEN
        IF old_server_attributes^.sap_open THEN
          IF (selected_titles_changed OR (old_server_attributes^.application_id <>
                new_server_attributes^.application_id) OR (new_server_attributes^.max_connections >
                old_server_attributes^.max_connections) OR (NOT new_server_attributes^.
                reserved_application_id AND (old_server_attributes^.message_priority <>
                new_server_attributes^.message_priority))) THEN
            delete_server_titles (old_server_attributes^.server_titles);
            register_titles := TRUE;
          IFEND;

          IF ((old_server_attributes^.application_id <> new_server_attributes^.application_id) OR
                (old_server_attributes^.message_priority <> new_server_attributes^.message_priority) OR
                (new_server_attributes^.max_connections > old_server_attributes^.max_connections)) THEN
            delete_server_added_titles (old_server_attributes^.added_titles);
            nlp$se_close_sap (old_server_attributes^.application_id, ignore_status);
            unassign_sap_identifier (old_server_attributes^.application_id.osi_sap_identifier);
            old_server_attributes^.sap_open := FALSE;
            new_server_attributes^.sap_open := FALSE;
            assign_sap_identifier (new_server_attributes^.reserved_application_id,
                  new_server_attributes^.application_id.osi_sap_identifier, status);
            IF status.normal THEN
              nlp$se_open_sap (nac$monitor_server_connections, TRUE, new_server_attributes^.max_connections,
                    status);
              IF NOT status.normal THEN
                unassign_sap_identifier (new_server_attributes^.application_id.osi_sap_identifier);
              IFEND;
            IFEND;
            IF status.normal THEN
              new_server_attributes^.sap_open := TRUE;
              sap_changed := TRUE;
            ELSE

{ An error occured while opening the new server sap; open the old server sap
{ and register the original server titles and server managed titles.

              nap$display_message (status);
              assign_sap_identifier (old_server_attributes^.reserved_application_id,
                    old_server_attributes^.application_id.osi_sap_identifier, status);
              IF status.normal THEN
                nlp$se_open_sap (nac$monitor_server_connections, TRUE, old_server_attributes^.max_connections,
                      status);
                IF NOT status.normal THEN
                  unassign_sap_identifier (old_server_attributes^.application_id.osi_sap_identifier);
                IFEND;
              IFEND;
              IF status.normal THEN
                old_server_attributes^.sap_open := TRUE;
                IF register_titles THEN
                  register_server_titles (old_server_attributes, ignore_status);
                IFEND;
                register_server_added_titles (old_server_attributes);
              ELSE
                nap$display_message (status);
                osp$set_status_abnormal (nac$status_id, nae$application_not_restored, server, status);
                old_server_attributes^.server_status := nac$application_inactive;
              IFEND;
              free_server_attributes ({free_added_titles} FALSE, {free server titles} selected_titles_changed,
                    new_server_attributes);
              nlp$release_exclusive_access (old_server_attributes^.access_control);
              nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
              osp$end_subsystem_activity;
              osp$pop_inhibit_job_recovery;
              close_cycle_1 (new_file_id);
              RETURN; {----->
            IFEND;
          IFEND;

{ If the server's selected titles were changed or the server sap was changed,
{ register the titles in the server titles list.

          IF register_titles THEN
            IF new_server_attributes^.server_titles <> NIL THEN
              osi_address.kind := nac$osi_transport_address;
              osi_address.transport_selector := new_server_attributes^.application_id.osi_sap_identifier;

              domain.kind := nac$catenet_domain;
              protocol := new_server_attributes^.protocol;
              user_identifier := new_server_attributes^.server;

            /register_title/
              FOR i := 1 TO UPPERBOUND (new_server_attributes^.server_titles^) DO
                server_title := ^new_server_attributes^.server_titles^ [i];
                nlp$register_title (server_title^.title, osi_address, protocol, ^server_title^.data,
                      server_title^.data_length, server_title^.priority, domain,
                      server_title^.distribute_title, nac$cdna_external, default_directory_password,
                      user_identifier, server_title^.directory_id, status);
                IF NOT status.normal THEN

{ An error occurred registering the new server titles; delete the titles just
{ registered, close the new sap, reopen the original sap and register the
{ original server titles and server managed titles.

                  nap$display_message (status);
                  FOR j := 1 TO i - 1 DO
                    server_title := ^new_server_attributes^.server_titles^ [j];
                    nlp$delete_registered_title (server_title^.title, default_directory_password,
                          server_title^.directory_id, ignore_status);
                  FOREND;
                  IF sap_changed THEN
                    nlp$se_close_sap (new_server_attributes^.application_id, ignore_status);
                    unassign_sap_identifier (new_server_attributes^.application_id.osi_sap_identifier);
                    new_server_attributes^.sap_open := FALSE;
                    assign_sap_identifier (old_server_attributes^.reserved_application_id,
                          old_server_attributes^.application_id.osi_sap_identifier, status);
                    IF status.normal THEN
                      nlp$se_open_sap (nac$monitor_server_connections, TRUE,
                            old_server_attributes^.max_connections, status);
                      IF NOT status.normal THEN
                        unassign_sap_identifier (old_server_attributes^.application_id.osi_sap_identifier);
                      IFEND;
                    IFEND;
                  IFEND;
                  IF status.normal THEN
                    old_server_attributes^.sap_open := TRUE;
                    register_server_titles (old_server_attributes, ignore_status);
                    IF sap_changed THEN
                      register_server_added_titles (old_server_attributes);
                    IFEND;
                  ELSE
                    nap$display_message (status);
                    osp$set_status_abnormal (nac$status_id, nae$application_not_restored, server, status);
                    old_server_attributes^.server_status := nac$application_inactive;
                  IFEND;
                  EXIT /register_title/; {----->
                IFEND;
              FOREND /register_title/;
              IF NOT status.normal THEN
                free_server_attributes ({free_added_titles} FALSE,
                      {free server titles} selected_titles_changed, new_server_attributes);
                nlp$release_exclusive_access (old_server_attributes^.access_control);
                nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
                osp$end_subsystem_activity;
                osp$pop_inhibit_job_recovery;
                close_cycle_1 (new_file_id);
                RETURN; {----->
              IFEND;
            IFEND;
          IFEND;

{ Register the server's server managed titles if the server's sap was changed.

          IF sap_changed THEN
            new_server_attributes^.added_titles := NIL;
            change_server_added_titles (old_server_attributes^.added_titles, new_server_attributes,
                  ignore_status);
          IFEND;

        IFEND;
      IFEND;
    IFEND;

{  Change the server job file.

    purge_server_file := FALSE;
    server_definition_file := application_job_file_path;
    server_definition_file [UPPERBOUND (server_definition_file)] := server;
    IF nam_initiated_server AND server_job_changed THEN
      IF new_server_definition^.service_file_defined THEN

{  Create a new high cycle with the new server job commands.

        define_server_job_file (server_definition_file, server_job, status);
        IF NOT status.normal THEN
          IF nav$namve_active THEN
            free_added_titles := old_server_attributes^.added_titles <> new_server_attributes^.added_titles;
            free_server_attributes (free_added_titles, {free server titles} selected_titles_changed,
                  old_server_attributes);
            nlp$release_exclusive_access (old_server_attributes^.access_control);
            nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
            osp$end_subsystem_activity;
            osp$pop_inhibit_job_recovery;
          IFEND;
          close_cycle_1 (new_file_id);
          RETURN; {----->
        IFEND;
        IF old_service_file_defined THEN

{ Change the retention period of the previous high cycle to 2 days.

          change_file_retention (server_definition_file, 2, ignore_status);
        IFEND;
      ELSE

{ The server job file was changed to undefined so set a boolean to purge the
{ old server job file after the server definition is successfully changed.

        purge_server_file := TRUE;
      IFEND;
    IFEND;

{ Change application definition file cycle 1 to new highest cycle.

    new_file_pointer.sequence_pointer := new_application_file;
    close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
    IF nav$namve_active THEN
      IF status.normal THEN

{ Change the server attributes entry to the new attribute values.

        free_added_titles := old_server_attributes^.added_titles <> new_server_attributes^.added_titles;
        free_server_attributes (free_added_titles, {free server titles} selected_titles_changed,
              old_server_attributes);
        old_server_attributes^ := new_server_attributes^;
        nav$appl_defn_time_stamp := modification_date_time;
        IF purge_server_file THEN
          osp$establish_block_exit_hndlr (^handle_block_exit);
          pfp$begin_system_authority;
          pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
          pfp$end_system_authority;
          osp$disestablish_cond_handler;
        IFEND;
      ELSE

{ Error encountered while changing the server; restore the server to it's
{ original state.

        nap$display_message (status);

{ Restore the server job file.

        IF nam_initiated_server AND server_job_changed THEN
          IF new_server_definition^.service_file_defined THEN
            osp$establish_block_exit_hndlr (^handle_block_exit);
            pfp$begin_system_authority;
            pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
            pfp$end_system_authority;
            osp$disestablish_cond_handler;
            IF old_service_file_defined THEN
              change_file_retention (server_definition_file, pfc$maximum_retention, ignore_status);
            IFEND;
          IFEND;
        IFEND;

        IF sap_changed THEN

{ Restore the server sap.

          delete_server_titles (new_server_attributes^.server_titles);
          delete_server_added_titles (new_server_attributes^.added_titles);

          nlp$se_close_sap (new_server_attributes^.application_id, ignore_status);
          unassign_sap_identifier (new_server_attributes^.application_id.osi_sap_identifier);
          assign_sap_identifier (old_server_attributes^.reserved_application_id,
                old_server_attributes^.application_id.osi_sap_identifier, status);
          IF status.normal THEN
            nlp$se_open_sap (nac$monitor_server_connections, TRUE, old_server_attributes^.max_connections,
                  status);
            IF NOT status.normal THEN
              unassign_sap_identifier (old_server_attributes^.application_id.osi_sap_identifier);
            IFEND;
          IFEND;
          IF NOT status.normal THEN
            nap$display_message (status);
            osp$set_status_abnormal (nac$status_id, nae$application_not_restored, server, status);
            old_server_attributes^.server_status := nac$application_inactive;
          IFEND;
        IFEND;

        IF status.normal THEN

{ Restore the server titles.

          IF register_titles THEN
            register_server_titles (old_server_attributes, ignore_status);
          IFEND;
        IFEND;

        IF status.normal THEN
          IF sap_changed THEN

{ Restore the server managed titles.

            old_server_attributes^.sap_open := TRUE;
            register_server_added_titles (old_server_attributes);
          IFEND;
        IFEND;

        free_added_titles := old_server_attributes^.added_titles <> new_server_attributes^.added_titles;
        free_server_attributes (free_added_titles, {free server titles} selected_titles_changed,
              new_server_attributes);
      IFEND;

    ELSE

{ NAMVE is not active.

      IF status.normal THEN
        IF purge_server_file THEN
          osp$establish_block_exit_hndlr (^handle_block_exit);
          pfp$begin_system_authority;
          pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
          pfp$end_system_authority;
          osp$disestablish_cond_handler;
        IFEND;
      ELSE

{ Error encountered while creating the new application definition file
{ high cycle; restore the server job file.

        nap$display_message (status);
        IF nam_initiated_server AND server_job_changed THEN
          IF new_server_definition^.service_file_defined THEN
            osp$establish_block_exit_hndlr (^handle_block_exit);
            pfp$begin_system_authority;
            pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
            pfp$end_system_authority;
            osp$disestablish_cond_handler;
            IF old_service_file_defined THEN
              change_file_retention (server_definition_file, pfc$maximum_retention, ignore_status);
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

    IF nav$namve_active THEN
      nlp$release_exclusive_access (old_server_attributes^.access_control);
      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    IFEND;

  PROCEND nap$change_server;
?? TITLE := '[XDCL, #GATE] nap$change_tcpip', EJECT ??
*copyc nah$change_tcpip

  PROCEDURE [XDCL, #GATE] nap$change_tcpip
    (    application: nat$application_name;
         maximum_sockets: nat$number_of_sockets;
         tcpip_capability: ost$name;
         tcpip_ring: ost$ring;
         tcpip_system_privilege: boolean;
     VAR status: ost$status);



    VAR
      i: 1 .. 0FFFF(16),
      ignore_status: ost$status,
      j: 1 .. 0FFFF(16),
      modification_date_time: ost$date_time,
      new_application_file: ^SEQ ( * ),
      new_client_pointers: ^nat$client_pointers,
      new_complete_tcpip_definition: ^nat$complete_tcpip_definition,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_attributes: ^nat$tcpip_attributes,
      new_tcpip_definition: ^nat$tcpip_definition,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_pointers: ^nat$client_pointers,
      old_complete_tcpip_definition: ^nat$complete_tcpip_definition,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_attributes: ^nat$tcpip_attributes,
      old_tcpip_definition: ^nat$tcpip_definition,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF NOT highest_cycle_open THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, change_client, status);
      RETURN; {----->
    IFEND;

    open_cycle_1 (new_file_pointer, new_file_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    new_application_file := new_file_pointer.sequence_pointer;
    RESET new_application_file;
    NEXT new_file_header IN new_application_file;
    RESET old_application_file;
    NEXT old_file_header IN old_application_file;

    IF old_file_header^.version <> nac$application_file_version THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      close_cycle_1 (new_file_id);
      RETURN; {----->
    IFEND;

{ Update new file header from old.

    new_file_header^ := old_file_header^;
    pmp$get_compact_date_time (modification_date_time, ignore_status);
    new_file_header^.modification_date_time := modification_date_time;


    IF new_file_header^.server_count > 0 THEN
      NEXT old_server_pointers: [1 .. new_file_header^.server_count] IN old_application_file;
      NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
    IFEND;

    IF new_file_header^.client_count > 0 THEN
      NEXT old_client_pointers: [1 .. new_file_header^.client_count] IN old_application_file;
      NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
    IFEND;

    IF new_file_header^.tcpip_count > 0 THEN
      NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
      NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
    IFEND;


{ Move server definitions to the new application file.

    FOR i := 1 TO new_file_header^.server_count DO
      move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

{ Move client definitions to the new application file.

    FOR i := 1 TO new_file_header^.client_count DO
      move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;


    NEXT new_complete_tcpip_definition: [[nat$tcpip_definition]] IN new_application_file;
    RESET new_complete_tcpip_definition;
    NEXT new_tcpip_definition IN new_complete_tcpip_definition;

{ Find the old definition of the tcpip application and move it to the
{ new application file.

    find_tcpip_definition (application, old_application_file, old_complete_tcpip_definition);
    IF old_complete_tcpip_definition = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      close_cycle_1 (new_file_id);
      RETURN; {----->
    IFEND;
    NEXT old_tcpip_definition IN old_complete_tcpip_definition;
    new_tcpip_definition^ := old_tcpip_definition^;

{  Set the new attribute values into the tcpip definition.

    new_tcpip_definition^.maximum_sockets := maximum_sockets;
    new_tcpip_definition^.tcpip_capability := tcpip_capability;
    new_tcpip_definition^.tcpip_ring := tcpip_ring;
    new_tcpip_definition^.tcpip_system_privilege := tcpip_system_privilege;

{  Setup relative pointers to the new tcpip definition.

    new_tcpip_pointers^ [1].application := application;
    new_tcpip_pointers^ [1].pointer := #REL (new_complete_tcpip_definition, new_application_file^);

{ Move the remaining tcpip definitions to the new application file.

    j := 1;
    FOR i := 1 TO new_file_header^.tcpip_count DO
      IF old_tcpip_pointers^ [i].application <> application THEN
        j := j + 1;
        move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [j], old_application_file,
              new_application_file);
      IFEND;
    FOREND;

    IF nav$namve_active THEN

{ Move the tcpip's old attributes to a local storage area and then change the
{ old attributes to their new values.

      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      nap$find_tcpip_attributes (application, old_tcpip_attributes);
      IF old_tcpip_attributes = NIL THEN
        osp$set_status_condition (nae$application_file_mismatch, status);
        nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
        osp$end_subsystem_activity;
        osp$pop_inhibit_job_recovery;
        close_cycle_1 (new_file_id);
        RETURN; {----->
      IFEND;
      PUSH new_tcpip_attributes;
      nlp$get_exclusive_access (old_tcpip_attributes^.access_control);
      new_tcpip_attributes^ := old_tcpip_attributes^;
      new_tcpip_attributes^.tcpip_capability := new_tcpip_definition^.tcpip_capability;
      new_tcpip_attributes^.tcpip_ring := new_tcpip_definition^.tcpip_ring;
      new_tcpip_attributes^.tcpip_system_privilege := new_tcpip_definition^.tcpip_system_privilege;
      new_tcpip_attributes^.maximum_sockets := new_tcpip_definition^.maximum_sockets;

{ Change application definition file cycle 1 to new highest cycle.

      new_file_pointer.sequence_pointer := new_application_file;
      close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
      IF status.normal THEN

{ Change the tcpip attributes entry to have the new attribute values.

        old_tcpip_attributes^ := new_tcpip_attributes^;
        nav$appl_defn_time_stamp := modification_date_time;
      ELSE

{ Error encountered while changing the tcpip application.

        nap$display_message (status);
      IFEND;

      nlp$release_exclusive_access (old_tcpip_attributes^.access_control);
      nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;

    ELSE

{ NAMVE is not active.  Change the application definition file cycle 1
{ to new highest cycle.

      new_file_pointer.sequence_pointer := new_application_file;
      close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
    IFEND;

  PROCEND nap$change_tcpip;
?? TITLE := '[XDCL, #GATE] nap$close_server_job_file', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to close the specified server job file.
{   The file should have previously been opened in ring 3.

  PROCEDURE [XDCL, #GATE] nap$close_server_job_file
    (    server_file_identifier: amt$file_identifier;
     VAR status: ost$status);

    verify_appl_mgmt_capability (status);
    IF status.normal THEN
      fsp$close_file (server_file_identifier, status);
    IFEND;

  PROCEND nap$close_server_job_file;
?? TITLE := '[XDCL, #GATE] nap$deactivate_client ', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$deactivate_client
    (    client: nat$application_name;
         terminate_active_connections: boolean;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$client_definition,
      complete_client_definition: ^nat$complete_client_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      v10_client_definition: ^nat$v10_client_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      nlp$get_exclusive_access (nav$client_attributes_list.access_control);
      nap$find_client_attributes (client, client_attributes);
      IF client_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
      ELSEIF client_attributes^.client_status = nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_already_inactiv, client, status);
      ELSEIF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, deactivate_client#, status);
      ELSE
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        find_client_definition (client, old_application_file, complete_client_definition);
        IF (complete_client_definition = NIL) THEN
          osp$set_status_condition (nae$application_file_error, status);
        ELSE
          deactivate_client (client_attributes, terminate_active_connections);
          client_attributes^.client_status := nac$application_inactive;
          IF (old_file_header^.version = nac$application_file_version) OR
                (old_file_header^.version = nac$v11_appl_file_version) THEN
            NEXT client_definition IN complete_client_definition;
            client_definition^.client_status := nac$application_inactive;
          ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
            NEXT v10_client_definition IN complete_client_definition;
            v10_client_definition^.client_status := nac$application_inactive;
          IFEND;
          pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);
          nav$appl_defn_time_stamp := old_file_header^.modification_date_time;
        IFEND;
      IFEND;

      nlp$release_exclusive_access (nav$client_attributes_list.access_control);
      osp$pop_inhibit_job_recovery;
    ELSE
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_client_definition (client, old_application_file, complete_client_definition);
      IF (complete_client_definition = NIL) THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_client#, status);
      ELSE
        IF (old_file_header^.version = nac$application_file_version) OR
              (old_file_header^.version = nac$v11_appl_file_version) THEN
          NEXT client_definition IN complete_client_definition;
          client_definition^.client_status := nac$application_inactive;
        ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
          NEXT v10_client_definition IN complete_client_definition;
          v10_client_definition^.client_status := nac$application_inactive;
        IFEND;
        pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);

        IF application_file_attached THEN
          nap$detach_application_file (local_status);
          IF (status.normal) AND (NOT local_status.normal) THEN
            status := local_status;
          ELSE
            nap$display_message (local_status);
          IFEND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$deactivate_client;
?? TITLE := '[XDCL, #GATE] nap$deactivate_server ', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$deactivate_server
    (    server: nat$application_name;
         terminate_active_connections: boolean;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      complete_server_definition: ^nat$complete_server_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      server_attributes: ^nat$server_attributes,
      server_definition: ^nat$server_definition,
      v10_server_definition: ^nat$v10_server_definition,
      wait_for_connection: ^nat$wait_for_connection;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (server, server_attributes);
      IF server_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSE
        nlp$get_exclusive_access (server_attributes^.access_control);
        IF server_attributes^.server_status = nac$application_inactive THEN
          osp$set_status_abnormal (nac$status_id, nae$application_already_inactiv, server, status);
        ELSEIF NOT highest_cycle_open THEN
          osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, deactivate_server#, status);
        ELSE
          RESET old_application_file;
          NEXT old_file_header IN old_application_file;
          find_server_definition (server, old_application_file, complete_server_definition);
          IF (complete_server_definition = NIL) THEN
            osp$set_status_abnormal (nac$status_id, nae$application_file_error, deactivate_server#, status);
          ELSE
            deactivate_server (server_attributes, terminate_active_connections);
            server_attributes^.server_status := nac$application_inactive;
{ Ready the server tasks waiting for a connection.
            wait_for_connection := server_attributes^.wait_for_connection;
            WHILE wait_for_connection <> NIL DO
              pmp$ready_task (wait_for_connection^.task_id, ignore_status);
              wait_for_connection := wait_for_connection^.next_entry;
            WHILEND;
            IF (old_file_header^.version = nac$application_file_version) OR
                  (old_file_header^.version = nac$v11_appl_file_version) THEN
              NEXT server_definition IN complete_server_definition;
              server_definition^.server_status := nac$application_inactive;
            ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
              NEXT v10_server_definition IN complete_server_definition;
              v10_server_definition^.server_status := nac$application_inactive;
            IFEND;
            pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);
            nav$appl_defn_time_stamp := old_file_header^.modification_date_time;
          IFEND;
        IFEND;

        nlp$release_exclusive_access (server_attributes^.access_control);
      IFEND;

      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;

    ELSE
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_server_definition (server, old_application_file, complete_server_definition);
      IF (complete_server_definition = NIL) THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_error, activate_server#, status);
      ELSE
        IF (old_file_header^.version = nac$application_file_version) OR
              (old_file_header^.version = nac$v11_appl_file_version) THEN
          NEXT server_definition IN complete_server_definition;
          server_definition^.server_status := nac$application_inactive;
        ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
          NEXT v10_server_definition IN complete_server_definition;
          v10_server_definition^.server_status := nac$application_inactive;
        IFEND;
        pmp$get_compact_date_time (old_file_header^.modification_date_time, ignore_status);
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$deactivate_server;
?? TITLE := '[XDCL, #GATE] nap$deactivate_tcpip', EJECT ??
*copyc nah$deactivate_tcpip

  PROCEDURE [XDCL, #GATE] nap$deactivate_tcpip
    (    application: nat$application_name;
         terminate_active_sockets: boolean;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      complete_tcpip_definition: ^nat$complete_tcpip_definition,
      i: integer,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      protocol: nat$protocol,
      tcpip_application: nat$application_name,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcpip_definition: ^nat$tcpip_definition,
      tcp_socket: ^nat$tcp_socket,
      tcp_socket_list: ^array [1 .. * ] of nat$tcp_socket,
      udp_socket: ^nat$udp_socket,
      udp_socket_list: ^array [1 .. * ] of nat$udp_socket;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      nlp$get_exclusive_access (nav$tcpip_attributes_list.access_control);
      nap$find_tcpip_attributes (application, tcpip_attributes);
      IF tcpip_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSEIF tcpip_attributes^.tcpip_status = nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_already_inactiv, application, status);
      ELSEIF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, deactivate_tcpip#, status);
      ELSE
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        find_tcpip_definition (application, old_application_file, complete_tcpip_definition);
        IF (complete_tcpip_definition = NIL) THEN
          osp$set_status_condition (nae$application_file_error, status);
        ELSE
          tcpip_attributes^.tcpip_status := nac$application_inactive;
          NEXT tcpip_definition IN complete_tcpip_definition;
          tcpip_definition^.tcpip_status := nac$application_inactive;
          pmp$get_compact_date_time (old_file_header^.modification_date_time, local_status);
          nav$appl_defn_time_stamp := old_file_header^.modification_date_time;
          tcp_socket_list := NIL;
          udp_socket_list := NIL;
          protocol := tcpip_attributes^.protocol;
          tcpip_application := application;
          IF (tcpip_attributes^.protocol = nac$stream_socket) AND
                (tcpip_attributes^.active_socket_count > 0) THEN
            PUSH tcp_socket_list: [1 .. tcpip_attributes^.active_socket_count];
            i := 1;
            tcp_socket := tcpip_attributes^.tcp_socket_list;
            WHILE tcp_socket <> NIL DO
              tcp_socket_list^ [i] := tcp_socket^;
              i := i + 1;
              tcp_socket := tcp_socket^.next_entry;
            WHILEND;
          ELSEIF (tcpip_attributes^.protocol = nac$datagram_socket) AND
                (tcpip_attributes^.active_socket_count <> 0) THEN
            PUSH udp_socket_list: [1 .. tcpip_attributes^.active_socket_count];
            i := 1;
            udp_socket := tcpip_attributes^.udp_socket_list;
            WHILE udp_socket <> NIL DO
              udp_socket_list^ [i] := udp_socket^;
              i := i + 1;
              udp_socket := udp_socket^.next_entry;
            WHILEND;
          IFEND;
        IFEND;
      IFEND;
      nlp$release_exclusive_access (nav$tcpip_attributes_list.access_control);
      osp$pop_inhibit_job_recovery;
      IF status.normal THEN
        deactivate_tcpip (tcpip_application, protocol, terminate_active_sockets, tcp_socket_list,
              udp_socket_list);
      IFEND;
    ELSE {NAMVE not active
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;
      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_tcpip_definition (application, old_application_file, complete_tcpip_definition);
      IF (complete_tcpip_definition = NIL) THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSE
        NEXT tcpip_definition IN complete_tcpip_definition;
        tcpip_definition^.tcpip_status := nac$application_inactive;
        pmp$get_compact_date_time (old_file_header^.modification_date_time, local_status);
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$deactivate_tcpip;
?? TITLE := '[XDCL, #GATE] nap$define_client ', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$define_client
    (    client: nat$application_name;
         max_connections: nat$number_of_connections;
         connection_priority: nat$network_message_priority;
         protocol: nat$protocol;
         reserved_application_id: boolean;
         application_id: nat$internet_sap_identifier;
         client_capability: ost$name;
         client_ring: ost$ring;
         client_system_privilege: boolean;
     VAR status: ost$status);

    VAR
      complete_client_definition: ^nat$complete_client_definition,
      i: integer,
      ignore_status: ost$status,
      modification_date_time: ost$date_time,
      new_client_attributes: ^nat$client_attributes,
      new_client_definition: ^nat$client_definition,
      new_client_pointers: ^nat$client_pointers,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      new_application_file: ^SEQ ( * ),
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF NOT highest_cycle_open THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, define_client, status);
      RETURN; {----->
    IFEND;

    open_cycle_1 (new_file_pointer, new_file_id, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;
    new_application_file := new_file_pointer.sequence_pointer;
    RESET new_application_file;
    NEXT new_file_header IN new_application_file;
    IF old_file_header^.version = nac$application_file_version THEN
      new_file_header^ := old_file_header^;
    ELSE
      RESET old_application_file;
      NEXT v10_v11_file_header IN old_application_file;
      new_file_header^.version := nac$application_file_version;
      new_file_header^.creation_date_time := old_file_header^.creation_date_time;
      new_file_header^.server_count := old_file_header^.server_count;
      new_file_header^.client_count := old_file_header^.client_count;
      new_file_header^.tcpip_count := 0;
    IFEND;
    pmp$get_compact_date_time (modification_date_time, ignore_status);
    new_file_header^.modification_date_time := modification_date_time;
    new_file_header^.client_count := old_file_header^.client_count + 1;

    IF old_file_header^.server_count > 0 THEN
      NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
      NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
    IFEND;

    IF old_file_header^.client_count > 0 THEN
      NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
    IFEND;
    NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;

    IF new_file_header^.tcpip_count > 0 THEN
      NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
      NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
    IFEND;


    FOR i := 1 TO old_file_header^.server_count DO
      move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

    NEXT complete_client_definition: [[nat$client_definition]] IN new_application_file;
    RESET complete_client_definition;
    NEXT new_client_definition IN complete_client_definition;
    new_client_definition^.client := client;
    new_client_definition^.client_status := nac$application_inactive;
    new_client_definition^.max_connections := max_connections;
    new_client_definition^.client_capability := client_capability;
    new_client_definition^.client_ring := client_ring;
    new_client_definition^.client_system_privilege := client_system_privilege;
    new_client_definition^.reserved_application_id := reserved_application_id;
    new_client_definition^.application_id := application_id;
    new_client_definition^.message_priority := connection_priority;
    new_client_definition^.flags.nam_accounting := FALSE;
    new_client_definition^.protocol := protocol;

{ setup the relative pointer to the client definition.

    new_client_pointers^ [1].client := client;
    new_client_pointers^ [1].pointer := #REL (complete_client_definition, new_application_file^);

    FOR i := 1 TO old_file_header^.client_count DO
      move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i + 1], old_application_file,
            new_application_file);
    FOREND;

{ Move tcpip definitions to the new application file.

    FOR i := 1 TO new_file_header^.tcpip_count DO
      move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

{ Setup the client attributes entry in network paged segment.

    osp$push_inhibit_job_recovery;
    IF nav$namve_active THEN
      osp$begin_subsystem_activity;
      define_client_attributes_entry (new_client_definition, new_client_attributes);
    IFEND;

    new_file_pointer.sequence_pointer := new_application_file;
    close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
    IF NOT status.normal THEN
      IF nav$namve_active THEN
        FREE new_client_attributes IN nav$network_paged_heap^;
        osp$end_subsystem_activity;
      IFEND;
      osp$pop_inhibit_job_recovery;
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      nav$appl_defn_time_stamp := modification_date_time;
      nlp$get_exclusive_access (nav$client_attributes_list.access_control);
      new_client_attributes^.next_entry := nav$client_attributes_list.client_attributes;
      nav$client_attributes_list.client_attributes := new_client_attributes;
      nlp$release_exclusive_access (nav$client_attributes_list.access_control);
      osp$end_subsystem_activity;
    IFEND;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$define_client;
?? TITLE := '[XDCL, #GATE] nap$define_server', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$define_server
    (    server: nat$application_name;
         selected_titles: ^nat$selected_titles_list;
         server_managed_titles: ^nat$title_pattern_list;
         max_connections: nat$number_of_connections;
         connection_priority: nat$network_message_priority;
         server_capability: ost$name;
         server_ring: ost$ring;
         server_system_privilege: boolean;
         accept_connection: boolean;
         client_validation_capability: ost$name;
         client_info_source: nat$client_info_source;
         client_addresses: ^array [1 .. * ] of nat$client_address,
         reserved_application_id: boolean;
         application_id: nat$internet_sap_identifier;
         protocol: nat$protocol;
         nam_initiated_server: boolean;
         server_job: amt$local_file_name;
         server_job_validation_source: nat$server_validation_source,
         server_job_max_connections: nat$number_of_connections;
     VAR status: ost$status);

    VAR
      actual_max_connections: nat$number_of_connections,
      complete_server_definition: ^nat$complete_server_definition,
      device_assigned: boolean,
      device_class: rmt$device_class,
      file_attributes: array [1 .. 1] of amt$file_item,
      i: integer,
      ignore_status: ost$status,
      modification_date_time: ost$date_time,
      new_application_file: ^SEQ ( * ),
      new_client_addresses: ^array [1 .. * ] of nat$client_address,
      new_client_pointers: ^nat$client_pointers,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_patterns_list: ^nat$title_pattern_list,
      new_server_attributes: ^nat$server_attributes,
      new_server_definition: ^nat$server_definition,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      new_titles_list: ^nat$selected_titles_list,
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      output_creation_attributes: array [1 .. 1] of fst$file_cycle_attribute,
      server_definition_file: array [1 .. 6] of pft$name,
      size_of_client_addresses: integer,
      size_of_selected_titles: integer,
      size_of_server_managed_titles: integer,
      unique_name: ost$name,
      v10_v11_file_header: ^nat$v10_v11_file_header;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF NOT (highest_cycle_open) THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, define_server, status);
      RETURN; {----->
    IFEND;

{ Check if server job file is valid.

    IF nam_initiated_server THEN
      rmp$get_device_class (server_job, device_assigned, device_class, status);
      IF (NOT status.normal) AND (device_class <> rmc$null_device) THEN
        nap$display_message (status);
        RETURN; {----->
      IFEND;

{ Define a file by the server name to hold the scl commands for the server.

      IF device_class <> rmc$null_device THEN
        server_definition_file := application_job_file_path;
        server_definition_file [UPPERBOUND (server_definition_file)] := server;
        pmp$get_unique_name (unique_name, ignore_status);
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        pfp$define (unique_name, server_definition_file, highest_cycle, default_password,
              pfc$maximum_retention, pfc$no_log, status);
        IF NOT status.normal THEN
          nap$display_message (status);
          IF (status.condition = pfe$unknown_last_subcatalog) OR
                (status.condition = pfe$unknown_nth_subcatalog) THEN
            pfp$define_catalog (application_job_catalog, status);
            IF NOT status.normal THEN
              pfp$end_system_authority;
              osp$disestablish_cond_handler;
              RETURN; {----->
            IFEND;
            pfp$define (unique_name, server_definition_file, highest_cycle, default_password,
                  pfc$maximum_retention, pfc$no_log, status);
          IFEND;
          IF NOT status.normal THEN
            pfp$end_system_authority;
            osp$disestablish_cond_handler;
            RETURN; {----->
          IFEND;
        IFEND;

{ Change the ring attributes so that the server job file is readable from
{ ring 13.

        output_creation_attributes [1].selector := fsc$ring_attributes;
        output_creation_attributes [1].ring_attributes.r1 := osc$tsrv_ring;
        output_creation_attributes [1].ring_attributes.r2 := osc$user_ring_2;
        output_creation_attributes [1].ring_attributes.r3 := osc$user_ring_2;
        fsp$copy_file (server_job, unique_name, NIL, NIL, ^output_creation_attributes, status);
        IF NOT status.normal THEN
          amp$return (unique_name, ignore_status);
          pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
          pfp$end_system_authority;
          osp$disestablish_cond_handler;
          nap$display_message (status);
          RETURN; {----->
        IFEND;

        pfp$end_system_authority;
        osp$disestablish_cond_handler;
        amp$return (unique_name, ignore_status);
      IFEND;
    IFEND;

    open_cycle_1 (new_file_pointer, new_file_id, status);
    IF NOT status.normal THEN
      IF (nam_initiated_server) AND (device_class <> rmc$null_device) THEN
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
        pfp$end_system_authority;
        osp$disestablish_cond_handler;
      IFEND;
      RETURN; {----->
    IFEND;

    RESET old_application_file;
    NEXT old_file_header IN old_application_file;
    new_application_file := new_file_pointer.sequence_pointer;
    RESET new_application_file;
    NEXT new_file_header IN new_application_file;

    IF old_file_header^.version = nac$application_file_version THEN
      new_file_header^ := old_file_header^;
    ELSE
      RESET old_application_file;
      NEXT v10_v11_file_header IN old_application_file;
      new_file_header^.version := nac$application_file_version;
      new_file_header^.creation_date_time := old_file_header^.creation_date_time;
      new_file_header^.server_count := old_file_header^.server_count;
      new_file_header^.client_count := old_file_header^.client_count;
      new_file_header^.tcpip_count := 0;
    IFEND;
    pmp$get_compact_date_time (modification_date_time, ignore_status);
    new_file_header^.modification_date_time := modification_date_time;
    new_file_header^.server_count := old_file_header^.server_count + 1;

    IF old_file_header^.server_count > 0 THEN
      NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
    IFEND;

    NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
    IF old_file_header^.client_count > 0 THEN
      NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
      NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
    IFEND;

    IF new_file_header^.tcpip_count > 0 THEN
      NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
      NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
    IFEND;

    IF selected_titles <> NIL THEN
      size_of_selected_titles := #SIZE (selected_titles^);
    ELSE
      size_of_selected_titles := 0;
    IFEND;

    IF server_managed_titles <> NIL THEN
      size_of_server_managed_titles := #SIZE (server_managed_titles^);
    ELSE
      size_of_server_managed_titles := 0;
    IFEND;

    IF client_addresses <> NIL THEN
      size_of_client_addresses := #SIZE (client_addresses^);
    ELSE
      size_of_client_addresses := 0;
    IFEND;

    NEXT complete_server_definition: [[REP (#SIZE (nat$server_definition) + size_of_selected_titles +
          size_of_server_managed_titles + size_of_client_addresses) OF cell]] IN new_application_file;
    RESET complete_server_definition;
    NEXT new_server_definition IN complete_server_definition;

{ Setup the new server definition.

    new_server_definition^.server := server;
    new_server_definition^.server_status := nac$application_inactive;

{ Determine actual max connections for timesharing server.
    actual_max_connections := max_connections;

    new_server_definition^.max_connections := actual_max_connections;
    IF selected_titles <> NIL THEN
      new_server_definition^.title_count := UPPERBOUND (selected_titles^);
    ELSE
      new_server_definition^.title_count := 0;
    IFEND;
    IF server_managed_titles <> NIL THEN
      new_server_definition^.server_managed_title_count := UPPERBOUND (server_managed_titles^);
    ELSE
      new_server_definition^.server_managed_title_count := 0;
    IFEND;
    new_server_definition^.server_capability := server_capability;
    new_server_definition^.server_ring := server_ring;
    new_server_definition^.server_system_privilege := server_system_privilege;
    new_server_definition^.accept_connection := accept_connection;
    new_server_definition^.client_validation_capability := client_validation_capability;
    new_server_definition^.client_info_source := client_info_source;
    IF client_addresses <> NIL THEN
      new_server_definition^.client_address_count := UPPERBOUND (client_addresses^);
    ELSE
      new_server_definition^.client_address_count := 0;
    IFEND;

    new_server_definition^.reserved_application_id := reserved_application_id;
    new_server_definition^.application_id := application_id;
    new_server_definition^.message_priority := connection_priority;
    new_server_definition^.flags.nam_accounting := FALSE;
    new_server_definition^.protocol := protocol;
    new_server_definition^.nam_initiated_server := nam_initiated_server;
    IF nam_initiated_server THEN
      new_server_definition^.server_job_validation_source := server_job_validation_source;
      new_server_definition^.server_job_max_connections := server_job_max_connections;
      new_server_definition^.service_file_defined := device_class <> rmc$null_device
    IFEND;

{ Setup the selected titles.

    IF new_server_definition^.title_count > 0 THEN
      NEXT new_titles_list: [1 .. new_server_definition^.title_count] IN complete_server_definition;
      new_titles_list^ := selected_titles^;
      new_server_definition^.selected_titles := #REL (new_titles_list, complete_server_definition^);
    IFEND;

{ Setup the server_managed titles.

    IF new_server_definition^.server_managed_title_count > 0 THEN
      NEXT new_patterns_list: [1 .. new_server_definition^.server_managed_title_count] IN
            complete_server_definition;
      new_patterns_list^ := server_managed_titles^;
      new_server_definition^.server_managed_titles := #REL (new_patterns_list, complete_server_definition^);
    IFEND;

{ Setup the client_addresses.

    IF new_server_definition^.client_address_count > 0 THEN
      NEXT new_client_addresses: [1 .. new_server_definition^.client_address_count] IN
            complete_server_definition;
      new_client_addresses^ := client_addresses^;
      new_server_definition^.client_addresses := #REL (new_client_addresses, complete_server_definition^);
    IFEND;

{ Setup the relative pointer to the new server definition.

    new_server_pointers^ [1].server := server;
    new_server_pointers^ [1].pointer := #REL (complete_server_definition, new_application_file^);

{ Move the remaining server and client definitions to the new file.

    FOR i := 1 TO old_file_header^.server_count DO
      move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i + 1], old_application_file,
            new_application_file);
    FOREND;

    FOR i := 1 TO old_file_header^.client_count DO
      move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

{ Move tcpip definitions to the new application file.

    FOR i := 1 TO new_file_header^.tcpip_count DO
      move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

{ Setup the server attributes entry in network paged segment.

    osp$push_inhibit_job_recovery;
    IF nav$namve_active THEN
      osp$begin_subsystem_activity;
      define_server_attributes_entry (complete_server_definition, new_server_attributes);
    IFEND;

    new_file_pointer.sequence_pointer := new_application_file;
    close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
    IF NOT status.normal THEN
      nap$display_message (status);
      IF (nam_initiated_server) AND (device_class <> rmc$null_device) THEN
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
        pfp$end_system_authority;
        osp$disestablish_cond_handler;
      IFEND;
      IF nav$namve_active THEN
        free_server_attributes_entry (new_server_attributes);
        osp$end_subsystem_activity;
      IFEND;
      osp$pop_inhibit_job_recovery;
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      nav$appl_defn_time_stamp := modification_date_time;
      nlp$get_exclusive_access (nav$server_attributes_list.access_control);
      new_server_attributes^.next_entry := nav$server_attributes_list.server_attributes;
      nav$server_attributes_list.server_attributes := new_server_attributes;
      nlp$release_exclusive_access (nav$server_attributes_list.access_control);
      osp$end_subsystem_activity;
    IFEND;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$define_server;
?? TITLE := '[XDCL, #GATE] nap$define_tcpip', EJECT ??
*copyc nah$define_tcpip

  PROCEDURE [XDCL, #GATE] nap$define_tcpip
    (    application: nat$application_name;
         maximum_sockets: nat$number_of_sockets;
         tcpip_capability: ost$name;
         tcpip_ring: ost$ring;
         tcpip_system_privilege: boolean;
         protocol: nat$protocol;
     VAR status: ost$status);


    VAR
      complete_tcpip_definition: ^nat$complete_tcpip_definition,
      i: integer,
      ignore_status: ost$status,
      modification_date_time: ost$date_time,
      new_application_file: ^SEQ ( * ),
      new_client_pointers: ^nat$client_pointers,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_attributes: ^nat$tcpip_attributes,
      new_tcpip_definition: ^nat$tcpip_definition,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF NOT (highest_cycle_open) THEN
      osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, define_tcpip, status);
      RETURN; {----->
    IFEND;

    open_cycle_1 (new_file_pointer, new_file_id, status);
    new_application_file := new_file_pointer.sequence_pointer;
    RESET new_application_file;
    NEXT new_file_header IN new_application_file;
    RESET old_application_file;
    NEXT old_file_header IN old_application_file;

{ Update new file header from old.
{ Old header will be different format if not latest version.

    IF old_file_header^.version = nac$application_file_version THEN
      new_file_header^ := old_file_header^;
    ELSE
      RESET old_application_file;
      NEXT v10_v11_file_header IN old_application_file;
      new_file_header^.version := nac$application_file_version;
      new_file_header^.creation_date_time := old_file_header^.creation_date_time;
      new_file_header^.server_count := old_file_header^.server_count;
      new_file_header^.client_count := old_file_header^.client_count;
      new_file_header^.tcpip_count := 0;
    IFEND;

    pmp$get_compact_date_time (modification_date_time, ignore_status);
    new_file_header^.modification_date_time := modification_date_time;
    new_file_header^.tcpip_count := new_file_header^.tcpip_count + 1;

    IF new_file_header^.server_count > 0 THEN
      NEXT old_server_pointers: [1 .. new_file_header^.server_count] IN old_application_file;
      NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
    IFEND;

    IF new_file_header^.client_count > 0 THEN
      NEXT old_client_pointers: [1 .. new_file_header^.client_count] IN old_application_file;
      NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
    IFEND;

    IF new_file_header^.tcpip_count > 1 THEN
      NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count - 1] IN old_application_file;
    IFEND;

    NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;

{ Move the server and client definitions to the new file.

    FOR i := 1 TO new_file_header^.server_count DO
      move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

    FOR i := 1 TO new_file_header^.client_count DO
      move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i], old_application_file,
            new_application_file);
    FOREND;

    NEXT complete_tcpip_definition: [[nat$tcpip_definition]] IN new_application_file;
    RESET complete_tcpip_definition;
    NEXT new_tcpip_definition IN complete_tcpip_definition;

{ Setup the new tcpip definition.

    new_tcpip_definition^.tcpip_application := application;
    new_tcpip_definition^.tcpip_status := nac$application_inactive;
    new_tcpip_definition^.maximum_sockets := maximum_sockets;
    new_tcpip_definition^.tcpip_capability := tcpip_capability;
    new_tcpip_definition^.tcpip_ring := tcpip_ring;
    new_tcpip_definition^.tcpip_system_privilege := tcpip_system_privilege;
    new_tcpip_definition^.flags.nam_accounting := FALSE;
    new_tcpip_definition^.protocol := protocol;
    new_tcpip_definition^.nam_initiated_server := FALSE;
    new_tcpip_definition^.accept_connection := FALSE;
    new_tcpip_definition^.reserved_application_id := FALSE;
    new_tcpip_definition^.application_id := 0;
    new_tcpip_definition^.client_validation_capability := osc$null_name;
    new_tcpip_definition^.client_info_source := nac$client_info_via_dialog;
    new_tcpip_definition^.title_count := 0;
    new_tcpip_definition^.tcpip_managed_title_count := 0;
    new_tcpip_definition^.tcpip_listen := FALSE;
    new_tcpip_definition^.tcpip_client_address_count := 0;
    new_tcpip_definition^.tcpip_job_validation_source := nac$server_job;
    new_tcpip_definition^.tcpip_job_max_sockets := UPPERVALUE (nat$number_of_sockets);
    new_tcpip_definition^.service_file_defined := FALSE;

{ Setup the relative pointer to the new tcpip definition.

    new_tcpip_pointers^ [1].application := application;
    new_tcpip_pointers^ [1].pointer := #REL (complete_tcpip_definition, new_application_file^);

    FOR i := 1 TO new_file_header^.tcpip_count - 1 DO
      move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i + 1], old_application_file,
            new_application_file);
    FOREND;

{ Setup the tcpip attributes entry in network paged segment.

    osp$push_inhibit_job_recovery;
    IF nav$namve_active THEN
      osp$begin_subsystem_activity;
      define_tcpip_attributes_entry (new_tcpip_definition, new_tcpip_attributes);
    IFEND;
    new_file_pointer.sequence_pointer := new_application_file;
    close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
    IF NOT status.normal THEN
      nap$display_message (status);
      IF nav$namve_active THEN
        FREE new_tcpip_attributes IN nav$network_paged_heap^;
        osp$end_subsystem_activity;
      IFEND;
      osp$pop_inhibit_job_recovery;
      RETURN; {----->
    IFEND;
    IF nav$namve_active THEN
      nav$appl_defn_time_stamp := modification_date_time;
      nlp$get_exclusive_access (nav$tcpip_attributes_list.access_control);

{  link new attributes in attribute list.

      new_tcpip_attributes^.next_entry := nav$tcpip_attributes_list.tcpip_attributes;
      nav$tcpip_attributes_list.tcpip_attributes := new_tcpip_attributes;
      nlp$release_exclusive_access (nav$tcpip_attributes_list.access_control);
      osp$end_subsystem_activity;
    IFEND;
    osp$pop_inhibit_job_recovery;
  PROCEND nap$define_tcpip;
?? TITLE := '[XDCL, #GATE] nap$delete_client', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$delete_client
    (    client: nat$application_name;
     VAR status: ost$status);

    VAR
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$client_definition,
      client_status: nat$application_status,
      complete_client_definition: ^nat$complete_client_definition,
      i: integer,
      ignore_status: ost$status,
      j: integer,
      modification_date_time: ost$date_time,
      new_application_file: ^SEQ ( * ),
      new_client_pointers: ^nat$client_pointers,
      new_file_id: amt$file_identifier,
      new_file_header: ^nat$application_file_header,
      new_file_pointer: amt$segment_pointer,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      previous_client_attributes: ^^nat$client_attributes,
      v10_client_definition: ^nat$v10_client_definition,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      nlp$get_exclusive_access (nav$client_attributes_list.access_control);
      client_attributes := nav$client_attributes_list.client_attributes;
      previous_client_attributes := ^nav$client_attributes_list.client_attributes;
      WHILE (client_attributes <> NIL) AND (client_attributes^.client <> client) DO
        previous_client_attributes := ^client_attributes^.next_entry;
        client_attributes := client_attributes^.next_entry;
      WHILEND;

      IF client_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
      ELSEIF client_attributes^.client_status <> nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_active, client, status);
      ELSEIF client_attributes^.connection_count > 0 THEN
        osp$set_status_abnormal (nac$status_id, nae$active_connections, client, status);
      ELSEIF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, delete_client, status);
      IFEND;
    ELSE

{ NAMVE is not active.

      IF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, delete_client, status);
      ELSE
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        find_client_definition (client, old_application_file, complete_client_definition);
        IF complete_client_definition = NIL THEN
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
        ELSE
          IF (old_file_header^.version = nac$application_file_version) OR
                (old_file_header^.version = nac$v11_appl_file_version) THEN
            NEXT client_definition IN complete_client_definition;
            client_status := client_definition^.client_status;
          ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
            NEXT v10_client_definition IN complete_client_definition;
            client_status := v10_client_definition^.client_status;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
                  status);
          IFEND;
          IF status.normal THEN
            IF client_status <> nac$application_inactive THEN
              osp$set_status_abnormal (nac$status_id, nae$application_active, client, status);
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
    IF status.normal THEN
      open_cycle_1 (new_file_pointer, new_file_id, status);
      IF status.normal THEN
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        new_application_file := new_file_pointer.sequence_pointer;
        RESET new_application_file;
        NEXT new_file_header IN new_application_file;
        IF old_file_header^.version = nac$application_file_version THEN
          new_file_header^ := old_file_header^;
        ELSE
          RESET old_application_file;
          NEXT v10_v11_file_header IN old_application_file;
          new_file_header^.version := nac$application_file_version;
          new_file_header^.creation_date_time := old_file_header^.creation_date_time;
          new_file_header^.server_count := old_file_header^.server_count;
          new_file_header^.client_count := old_file_header^.client_count;
          new_file_header^.tcpip_count := 0;
        IFEND;
        pmp$get_compact_date_time (modification_date_time, ignore_status);
        new_file_header^.modification_date_time := modification_date_time;
        new_file_header^.client_count := old_file_header^.client_count - 1;
        IF new_file_header^.server_count > 0 THEN
          NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
          NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
        IFEND;

        IF old_file_header^.client_count > 0 THEN
          NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
        IFEND;
        IF new_file_header^.client_count > 0 THEN
          NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
        IFEND;

        IF new_file_header^.tcpip_count > 0 THEN
          NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
          NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
        IFEND;

        FOR i := 1 TO new_file_header^.server_count DO
          move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i], old_application_file,
                new_application_file);
        FOREND;

        IF new_file_header^.client_count > 0 THEN
          j := 1;
          FOR i := 1 TO old_file_header^.client_count DO
            IF old_client_pointers^ [i].client <> client THEN
              move_client_definition (old_client_pointers^ [i], new_client_pointers^ [j],
                    old_application_file, new_application_file);
              j := j + 1;
            IFEND;
          FOREND;
        IFEND;

{ Move tcpip definitions to the new application file.

        FOR i := 1 TO new_file_header^.tcpip_count DO
          move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i], old_application_file,
                new_application_file);
        FOREND;

        new_file_pointer.sequence_pointer := new_application_file;
        close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
        IF status.normal AND nav$namve_active THEN
          previous_client_attributes^ := client_attributes^.next_entry;
          FREE client_attributes IN nav$network_paged_heap^;
          nav$appl_defn_time_stamp := modification_date_time;
        IFEND;
      IFEND;
    IFEND;

    IF nav$namve_active THEN
      nlp$release_exclusive_access (nav$client_attributes_list.access_control);
      osp$pop_inhibit_job_recovery;
    IFEND;

  PROCEND nap$delete_client;
?? TITLE := '[XDCL, #GATE] nap$delete_server', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$delete_server
    (    server: nat$application_name;
     VAR status: ost$status);

    VAR
      complete_server_definition: ^nat$complete_server_definition,
      delete_server_job_file: boolean,
      i: integer,
      ignore_status: ost$status,
      j: integer,
      modification_date_time: ost$date_time,
      new_client_pointers: ^nat$client_pointers,
      new_file_header: ^nat$application_file_header,
      new_file_id: amt$file_identifier,
      new_file_pointer: amt$segment_pointer,
      new_application_file: ^SEQ ( * ),
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      server_attributes: ^nat$server_attributes,
      server_definition: ^nat$server_definition,
      server_definition_file: array [1 .. 6] of pft$name,
      server_status: nat$application_status,
      previous_server_attributes: ^^nat$server_attributes,
      v10_server_definition: ^nat$v10_server_definition,
      v10_v11_file_header: ^nat$v10_v11_file_header;

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      nlp$get_exclusive_access (nav$server_attributes_list.access_control);
      server_attributes := nav$server_attributes_list.server_attributes;
      previous_server_attributes := ^nav$server_attributes_list.server_attributes;

      WHILE (server_attributes <> NIL) AND (server_attributes^.server <> server) DO
        previous_server_attributes := ^server_attributes^.next_entry;
        server_attributes := server_attributes^.next_entry;
      WHILEND;

      IF server_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSEIF server_attributes^.server_status <> nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_active, server, status);
      ELSEIF server_attributes^.connection_count > 0 THEN
        osp$set_status_abnormal (nac$status_id, nae$active_connections, server, status);
      ELSEIF server_attributes^.server_job_list <> NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$server_jobs_attached, server, status);
      ELSEIF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, delete_server, status);
      IFEND;
    ELSE

{ NAMVE is not active.

      IF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, delete_server, status);
      ELSE
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        find_server_definition (server, old_application_file, complete_server_definition);
        IF complete_server_definition = NIL THEN
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
        ELSE
          IF (old_file_header^.version = nac$application_file_version) OR
                (old_file_header^.version = nac$v11_appl_file_version) THEN
            NEXT server_definition IN complete_server_definition;
            server_status := server_definition^.server_status;
          ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
            NEXT v10_server_definition IN complete_server_definition;
            server_status := v10_server_definition^.server_status;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
                  status);
          IFEND;
          IF status.normal THEN
            IF server_status <> nac$application_inactive THEN
              osp$set_status_abnormal (nac$status_id, nae$application_active, server, status);
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
    IF status.normal THEN
      open_cycle_1 (new_file_pointer, new_file_id, status);
      IF status.normal THEN
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        new_application_file := new_file_pointer.sequence_pointer;
        RESET new_application_file;
        NEXT new_file_header IN new_application_file;

        IF old_file_header^.version = nac$application_file_version THEN
          new_file_header^ := old_file_header^;
        ELSE
          RESET old_application_file;
          NEXT v10_v11_file_header IN old_application_file;
          new_file_header^.version := nac$application_file_version;
          new_file_header^.creation_date_time := old_file_header^.creation_date_time;
          new_file_header^.server_count := old_file_header^.server_count;
          new_file_header^.client_count := old_file_header^.client_count;
          new_file_header^.tcpip_count := 0;
        IFEND;
        pmp$get_compact_date_time (modification_date_time, ignore_status);
        new_file_header^.modification_date_time := modification_date_time;
        new_file_header^.server_count := old_file_header^.server_count - 1;

        IF old_file_header^.server_count > 0 THEN
          NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
        IFEND;
        IF new_file_header^.server_count > 0 THEN
          NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
        IFEND;

        IF new_file_header^.client_count > 0 THEN
          NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
          NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
        IFEND;

        IF new_file_header^.tcpip_count > 0 THEN
          NEXT old_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN old_application_file;
          NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
        IFEND;

        IF new_file_header^.server_count > 0 THEN
          j := 1;
          FOR i := 1 TO old_file_header^.server_count DO
            IF old_server_pointers^ [i].server <> server THEN
              move_server_definition (old_server_pointers^ [i], new_server_pointers^ [j],
                    old_application_file, new_application_file);
              j := j + 1;
            IFEND;
          FOREND;
        IFEND;

        FOR i := 1 TO new_file_header^.client_count DO
          move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i], old_application_file,
                new_application_file);
        FOREND;

{ Move tcpip definitions to the new application file.

        FOR i := 1 TO new_file_header^.tcpip_count DO
          move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [i], old_application_file,
                new_application_file);
        FOREND;

        delete_server_job_file := FALSE;
        IF nav$namve_active THEN
          delete_server_job_file := (server_attributes^.nam_initiated_server) AND
                (server_attributes^.service_file_defined);
        ELSE
          find_server_definition (server, old_application_file, complete_server_definition);
          IF complete_server_definition <> NIL THEN
            IF old_file_header^.version = nac$application_file_version THEN
              NEXT server_definition IN complete_server_definition;
              delete_server_job_file := (server_definition^.nam_initiated_server) AND
                    (server_definition^.service_file_defined);
            ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
              NEXT v10_server_definition IN complete_server_definition;
              delete_server_job_file := (v10_server_definition^.nam_initiated_server) AND
                    (v10_server_definition^.service_file_defined);
            IFEND;
          IFEND;
        IFEND;

        new_file_pointer.sequence_pointer := new_application_file;
        close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
        IF status.normal THEN
          IF delete_server_job_file THEN
            server_definition_file := application_job_file_path;
            server_definition_file [UPPERBOUND (server_definition_file)] := server;
            osp$establish_block_exit_hndlr (^handle_block_exit);
            pfp$begin_system_authority;
            pfp$purge (server_definition_file, highest_cycle, default_password, ignore_status);
            pfp$end_system_authority;
            osp$disestablish_cond_handler;
          IFEND;
          IF nav$namve_active THEN
            previous_server_attributes^ := server_attributes^.next_entry;
            free_server_attributes_entry (server_attributes);
            nav$appl_defn_time_stamp := modification_date_time;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

    IF nav$namve_active THEN
      nlp$release_exclusive_access (nav$server_attributes_list.access_control);
      osp$pop_inhibit_job_recovery;
    IFEND;

  PROCEND nap$delete_server;
?? TITLE := '[XDCL, #GATE] nap$delete_server_title ', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$delete_server_title
    (    server: nat$application_name;
         title_pattern: nat$title_pattern;
     VAR status: ost$status);

*copyc nah$delete_server_title

    VAR
      added_title: ^^nat$added_title,
      i: integer,
      next_title: ^nat$added_title,
      server_attributes: ^nat$server_attributes,
      title_found: boolean;

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

    status.normal := TRUE;
    title_found := FALSE;

    IF STRLENGTH (title_pattern) < 1 THEN
      osp$set_status_abnormal (nac$status_id, nae$title_pattern_too_short, delete_server_title, status);
    ELSEIF STRLENGTH (title_pattern) > nac$max_title_length THEN
      osp$set_status_abnormal (nac$status_id, nae$title_pattern_too_long, delete_server_title, status);
      osp$append_status_integer (osc$status_parameter_delimiter, STRLENGTH (title_pattern),
            10, FALSE, status);
    ELSE
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (server, server_attributes);
      IF server_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSE
        nlp$get_exclusive_access (server_attributes^.access_control);
        nap$validate_user (server_attributes^.server_capability, server_attributes^.server_ring,
              server_attributes^.server_system_privilege, status);
        IF NOT status.normal THEN
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
        ELSEIF server_attributes^.server_status = nac$application_inactive THEN
          osp$set_status_abnormal (nac$status_id, nae$application_inactive, server, status);
        ELSEIF (NOT server_attributes^.nam_initiated_server) AND
              (NOT server_attributes^.protocol_activated) THEN
          osp$set_status_abnormal (nac$status_id, nae$no_server_job_attached, server, status);
        ELSE
          added_title := ^server_attributes^.added_titles;
          WHILE added_title^ <> NIL DO
            IF nlp$name_match (title_pattern, added_title^^.title) THEN
              nlp$delete_registered_title (added_title^^.title, default_directory_password,
                    added_title^^.identifier, status);
              IF NOT status.normal THEN
                nap$display_message (status);
              IFEND;
              title_found := TRUE;
              next_title := added_title^^.next_title;
              FREE added_title^ IN nav$network_paged_heap^;
              added_title^ := next_title;
            ELSE
              added_title := ^added_title^^.next_title;
            IFEND;
          WHILEND;
        IFEND;
        nlp$release_exclusive_access (server_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
      IF status.normal AND NOT title_found THEN
        osp$set_status_abnormal (nac$status_id, nae$no_title_match, delete_server_title, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, server, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, title_pattern, status);
      IFEND;
    IFEND;

  PROCEND nap$delete_server_title;
?? TITLE := '[XDCL] nap$delete_connection', EJECT ??

  PROCEDURE [XDCL] nap$delete_connection
    (    application: nat$application_name;
         application_type: nat$application_type;
         connection_id: nat$connection_id;
     VAR active_file: boolean;
     VAR status: ost$status);

    VAR
      assigned_connection: ^nat$server_connection_attribute,
      client_attributes: ^nat$client_attributes,
      client_connection: ^nat$client_connection_attribute,
      ignore_status: ost$status,
      previous_assigned_connection: ^^nat$server_connection_attribute,
      previous_server_connection: ^^nat$server_connection_attribute,
      server_attributes: ^nat$server_attributes,
      previous_client_connection: ^^nat$client_connection_attribute,
      server_connection: ^nat$server_connection_attribute,
      server_job_attributes: ^nat$server_job_attributes;

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

    osp$push_inhibit_job_recovery;
    active_file := TRUE;
    osp$begin_subsystem_activity;
    IF application_type = nac$server_application THEN
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (application, server_attributes);
      IF server_attributes <> NIL THEN
        nlp$get_exclusive_access (server_attributes^.access_control);
{ Search server connections list.
        server_connection := server_attributes^.server_connections_list;
        previous_server_connection := ^server_attributes^.server_connections_list;
        WHILE (server_connection <> NIL) AND (server_connection^.connection_id <> connection_id) DO
          previous_server_connection := ^server_connection^.next_entry;
          server_connection := server_connection^.next_entry;
        WHILEND;

        IF server_connection <> NIL THEN
          previous_server_connection^ := server_connection^.next_entry;
          server_attributes^.connection_count := server_attributes^.connection_count - 1;
          IF server_connection^.connection_kind = nac$owned_by_job THEN
            server_job_attributes := server_attributes^.server_job_list;
            WHILE (server_job_attributes <> NIL) AND (server_job_attributes^.job_name <>
                  server_connection^.job_name) DO
              server_job_attributes := server_job_attributes^.next_entry;
            WHILEND;
            IF server_job_attributes <> NIL THEN
              server_job_attributes^.connection_count := server_job_attributes^.connection_count - 1;
            IFEND;
          IFEND;
          FREE server_connection IN nav$network_paged_heap^;
        ELSE
{ Search assigned connections list.
          assigned_connection := server_attributes^.assigned_connections_list;
          previous_assigned_connection := ^server_attributes^.assigned_connections_list;
          WHILE (assigned_connection <> NIL) AND (assigned_connection^.connection_id <> connection_id) DO
            previous_assigned_connection := ^assigned_connection^.next_entry;
            assigned_connection := assigned_connection^.next_entry;
          WHILEND;
          IF assigned_connection = NIL THEN
{ ***DEBUG  pmp$log ('AM Lost connection id', ignore_status);
          ELSE
            active_file := FALSE;
            previous_assigned_connection^ := assigned_connection^.next_entry;
            server_attributes^.connection_count := server_attributes^.connection_count - 1;
            IF assigned_connection^.directed_connection THEN
              server_job_attributes := server_attributes^.server_job_list;
              WHILE (server_job_attributes <> NIL) AND (server_job_attributes^.job_name <>
                    assigned_connection^.destination_job_name) DO
                server_job_attributes := server_job_attributes^.next_entry;
              WHILEND;
              IF server_job_attributes <> NIL THEN
                server_job_attributes^.assigned_connection_count :=
                      server_job_attributes^.assigned_connection_count - 1;
              IFEND;
            IFEND;
            FREE assigned_connection IN nav$network_paged_heap^;
          IFEND;
        IFEND;

        IF (server_attributes^.server_status = nac$application_inactive) AND
              (server_attributes^.connection_count = 0) THEN
          nlp$se_close_sap (server_attributes^.application_id, ignore_status);
          unassign_sap_identifier (server_attributes^.application_id.osi_sap_identifier);
          IF NOT server_attributes^.reserved_application_id THEN
            server_attributes^.application_id.osi_sap_identifier := 0;
          IFEND;
          server_attributes^.sap_open := FALSE;
        IFEND;
        nlp$release_exclusive_access (server_attributes^.access_control);
      IFEND;

      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    ELSE
      nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
      nap$find_client_attributes (application, client_attributes);
      IF client_attributes <> NIL THEN
        nlp$get_exclusive_access (client_attributes^.access_control);
        client_connection := client_attributes^.client_connections_list;
        previous_client_connection := ^client_attributes^.client_connections_list;
        WHILE (client_connection <> NIL) AND (client_connection^.connection_id <> connection_id) DO
          previous_client_connection := ^client_connection^.next_entry;
          client_connection := client_connection^.next_entry;
        WHILEND;

        IF client_connection <> NIL THEN
          previous_client_connection^ := client_connection^.next_entry;
          FREE client_connection IN nav$network_paged_heap^;
          client_attributes^.connection_count := client_attributes^.connection_count - 1;
        IFEND;

        IF (client_attributes^.client_status = nac$application_inactive) AND
              (client_attributes^.connection_count = 0) THEN
          nlp$se_close_sap (client_attributes^.application_id, ignore_status);
          unassign_sap_identifier (client_attributes^.application_id.osi_sap_identifier);
          IF NOT client_attributes^.reserved_application_id THEN
            client_attributes^.application_id.osi_sap_identifier := 0;
          IFEND;
          client_attributes^.sap_open := FALSE;
        IFEND;
        nlp$release_exclusive_access (client_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
    IFEND;

    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$delete_connection;
?? TITLE := '[XDCL, #GATE] nap$delete_tcpip', EJECT ??
*copyc nah$delete_tcpip

  PROCEDURE [XDCL, #GATE] nap$delete_tcpip
    (    application: nat$application_name;
     VAR status: ost$status);

    VAR
      complete_tcpip_definition: ^nat$complete_tcpip_definition,
      i: integer,
      ignore_status: ost$status,
      j: integer,
      modification_date_time: ost$date_time,
      new_application_file: ^SEQ ( * ),
      new_client_pointers: ^nat$client_pointers,
      new_file_id: amt$file_identifier,
      new_file_header: ^nat$application_file_header,
      new_file_pointer: amt$segment_pointer,
      new_server_pointers: ^nat$server_pointers,
      new_tcpip_pointers: ^nat$tcpip_pointers,
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      previous_tcpip_attributes: ^^nat$tcpip_attributes,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcpip_definition: ^nat$tcpip_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      nlp$get_exclusive_access (nav$tcpip_attributes_list.access_control);

{ Find tcpip applications attributes.

      tcpip_attributes := nav$tcpip_attributes_list.tcpip_attributes;
      previous_tcpip_attributes := ^nav$tcpip_attributes_list.tcpip_attributes;
      WHILE (tcpip_attributes <> NIL) AND (tcpip_attributes^.tcpip_application <> application) DO
        previous_tcpip_attributes := ^tcpip_attributes^.next_entry;
        tcpip_attributes := tcpip_attributes^.next_entry;
      WHILEND;

      IF tcpip_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSEIF tcpip_attributes^.tcpip_status <> nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_active, application, status);
      ELSEIF tcpip_attributes^.active_socket_count > 0 THEN
        osp$set_status_abnormal (nac$status_id, nae$active_sockets, application, status);
      ELSEIF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, delete_tcpip, status);
      IFEND;
    ELSE { NAMVE is not active.


      IF NOT highest_cycle_open THEN
        osp$set_status_abnormal (nac$status_id, nae$application_file_not_open, delete_tcpip, status);
      ELSE { Application definition file highest cycle open.
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        find_tcpip_definition (application, old_application_file, complete_tcpip_definition);
        IF complete_tcpip_definition = NIL THEN
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
        ELSE { tcpip application definition found on appl definition file.
          NEXT tcpip_definition IN complete_tcpip_definition;
          IF status.normal THEN
            IF tcpip_definition^.tcpip_status <> nac$application_inactive THEN
              osp$set_status_abnormal (nac$status_id, nae$application_active, application, status);
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    IFEND;
    IF status.normal THEN
      open_cycle_1 (new_file_pointer, new_file_id, status);
      IF status.normal THEN
        RESET old_application_file;
        NEXT old_file_header IN old_application_file;
        new_application_file := new_file_pointer.sequence_pointer;
        RESET new_application_file;
        NEXT new_file_header IN new_application_file;
        new_file_header^ := old_file_header^;
        pmp$get_compact_date_time (modification_date_time, ignore_status);
        new_file_header^.modification_date_time := modification_date_time;
        new_file_header^.tcpip_count := old_file_header^.tcpip_count - 1;

        IF new_file_header^.server_count > 0 THEN
          NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
          NEXT new_server_pointers: [1 .. new_file_header^.server_count] IN new_application_file;
        IFEND;

        IF new_file_header^.client_count > 0 THEN
          NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
          NEXT new_client_pointers: [1 .. new_file_header^.client_count] IN new_application_file;
        IFEND;

        IF old_file_header^.tcpip_count > 0 THEN
          NEXT old_tcpip_pointers: [1 .. old_file_header^.tcpip_count] IN old_application_file;
        IFEND;
        IF new_file_header^.tcpip_count > 0 THEN
          NEXT new_tcpip_pointers: [1 .. new_file_header^.tcpip_count] IN new_application_file;
        IFEND;

        FOR i := 1 TO new_file_header^.server_count DO
          move_server_definition (old_server_pointers^ [i], new_server_pointers^ [i], old_application_file,
                new_application_file);
        FOREND;

        FOR i := 1 TO new_file_header^.client_count DO
          move_client_definition (old_client_pointers^ [i], new_client_pointers^ [i], old_application_file,
                new_application_file);
        FOREND;


        IF new_file_header^.tcpip_count > 0 THEN
          j := 1;
          FOR i := 1 TO old_file_header^.tcpip_count DO
            IF old_tcpip_pointers^ [i].application <> application THEN
              move_tcpip_definition (old_tcpip_pointers^ [i], new_tcpip_pointers^ [j], old_application_file,
                    new_application_file);
              j := j + 1;
            IFEND;
          FOREND;
        IFEND;

        new_file_pointer.sequence_pointer := new_application_file;
        close_and_change_cycle_1 (new_file_id, new_file_pointer, status);
        IF status.normal AND nav$namve_active THEN

{ Delink attributes entry and release storage.

          previous_tcpip_attributes^ := tcpip_attributes^.next_entry;
          FREE tcpip_attributes IN nav$network_paged_heap^;
          nav$appl_defn_time_stamp := modification_date_time;
        IFEND;
      IFEND;
    IFEND;

    IF nav$namve_active THEN
      nlp$release_exclusive_access (nav$tcpip_attributes_list.access_control);
      osp$pop_inhibit_job_recovery;
    IFEND;
  PROCEND nap$delete_tcpip;
?? TITLE := '[XDCL, #GATE] nap$detach_application_file', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to close and return the highest cycle of the
{   application file. Application management capability is assumed since it would
{   have been required to attach the file.

  PROCEDURE [XDCL, #GATE] nap$detach_application_file
    (VAR status: ost$status);

    VAR
      highest_cycle_instance: ^bat$task_file_entry,
      highest_cycle_lfn: amt$local_file_name;

    status.normal := TRUE;
    IF highest_cycle_open THEN
      highest_cycle_instance := baf$task_file_entry_p (highest_cycle_id);
      highest_cycle_lfn := highest_cycle_instance^.local_file_name;
      fsp$close_file (highest_cycle_id, status);
      IF status.normal THEN
        highest_cycle_open := FALSE;
        amp$return (highest_cycle_lfn, status);
      IFEND;
    IFEND;

  PROCEND nap$detach_application_file;
?? TITLE := '[XDCL, #GATE] nap$detach_server_application', EJECT ??
*copyc nah$detach_server_application

  PROCEDURE [XDCL, #GATE] nap$detach_server_application
    (    server: nat$application_name;
     VAR status: ost$status);

    VAR
      job_name: jmt$system_supplied_name,
      user_supplied_name: jmt$user_supplied_name;


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

    status.normal := TRUE;
    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);

    pmp$get_job_names (user_supplied_name, job_name, {ignore} status);
    status.normal := TRUE;
    detach_server_application (job_name, server, status);

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$detach_server_application;
?? TITLE := '[XDCL, #GATE] nap$detach_specific_server_appl', EJECT ??

{ PURPOSE:
{   The purpose of this request is to detach the specified server application.  The
{   request is the same as nap$detach_server_application except that the job name is
{   a parameter on this request.

  PROCEDURE [XDCL, #GATE] nap$detach_specific_server_appl
    (    system_job_name: jmt$system_supplied_name;
         server: nat$application_name;
     VAR status: ost$status);


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

    status.normal := TRUE;
    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);

    detach_server_application (system_job_name, server, status);

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$detach_specific_server_appl;
?? TITLE := '[XDCL, #GATE] nap$get_application_names', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_application_names
    (    type_of_applications: set of nat$application_type;
     VAR application_attributes: array [1 .. * ] of nat$application_attribute;
     VAR number_of_applications: nat$max_applications;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_attributes: ^nat$client_attributes,
      i: integer,
      j: integer,
      old_client_pointers: ^nat$client_pointers,
      old_file_header: ^nat$application_file_header,
      old_server_pointers: ^nat$server_pointers,
      old_tcpip_pointers: ^nat$tcpip_pointers,
      server_attributes: ^nat$server_attributes,
      tcpip_attributes: ^nat$tcpip_attributes,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    number_of_applications := 0;
    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;

{ Sum up all defined client applications.

      IF nac$client_application IN type_of_applications THEN
        nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
        client_attributes := nav$client_attributes_list.client_attributes;
        WHILE client_attributes <> NIL DO
          number_of_applications := number_of_applications + 1;
          client_attributes := client_attributes^.next_entry;
        WHILEND;

        nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
      IFEND;

{ Sum up all defined server applications.

      IF nac$server_application IN type_of_applications THEN
        nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
        server_attributes := nav$server_attributes_list.server_attributes;
        WHILE server_attributes <> NIL DO
          number_of_applications := number_of_applications + 1;
          server_attributes := server_attributes^.next_entry;
        WHILEND;

        nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      IFEND;

{ Sum up all defined tcpip applications.

      IF nac$tcpip_application IN type_of_applications THEN
        nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
        tcpip_attributes := nav$tcpip_attributes_list.tcpip_attributes;
        WHILE tcpip_attributes <> NIL DO
          number_of_applications := number_of_applications + 1;
          tcpip_attributes := tcpip_attributes^.next_entry;
        WHILEND;

        nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      IFEND;

      IF (number_of_applications > 0) AND (number_of_applications <= UPPERBOUND (application_attributes)) THEN
        i := LOWERBOUND (application_attributes);

        IF nac$server_application IN type_of_applications THEN
          nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
          server_attributes := nav$server_attributes_list.server_attributes;
          WHILE server_attributes <> NIL DO
            application_attributes [i].name := server_attributes^.server;
            application_attributes [i].application_type := nac$server_application;
            i := i + 1;
            server_attributes := server_attributes^.next_entry;
          WHILEND;

          nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);

        IFEND;
        IF nac$client_application IN type_of_applications THEN
          nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
          client_attributes := nav$client_attributes_list.client_attributes;
          WHILE client_attributes <> NIL DO
            application_attributes [i].name := client_attributes^.client;
            application_attributes [i].application_type := nac$client_application;
            i := i + 1;
            client_attributes := client_attributes^.next_entry;
          WHILEND;

          nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
        IFEND;
        IF nac$tcpip_application IN type_of_applications THEN
          nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
          tcpip_attributes := nav$tcpip_attributes_list.tcpip_attributes;
          WHILE tcpip_attributes <> NIL DO
            application_attributes [i].name := tcpip_attributes^.tcpip_application;
            application_attributes [i].application_type := nac$tcpip_application;
            i := i + 1;
            tcpip_attributes := tcpip_attributes^.next_entry;
          WHILEND;

          nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
        IFEND;
      IFEND;
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE

{ NAMVE is not active.

      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

{ Sum up all defined client and server applications.

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;

      IF old_file_header^.version <> nac$application_file_version THEN
        RESET old_application_file;
        NEXT v10_v11_file_header IN old_application_file;
      IFEND;
      IF old_file_header^.server_count > 0 THEN
        NEXT old_server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;
      IFEND;
      IF old_file_header^.client_count > 0 THEN
        NEXT old_client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;
      IFEND;
      IF old_file_header^.version = nac$application_file_version THEN
        IF old_file_header^.tcpip_count > 0 THEN
          NEXT old_tcpip_pointers: [1 .. old_file_header^.tcpip_count] IN old_application_file;
        IFEND;
      IFEND;
      IF nac$client_application IN type_of_applications THEN
        number_of_applications := old_file_header^.client_count;
      IFEND;
      IF nac$server_application IN type_of_applications THEN
        number_of_applications := number_of_applications + old_file_header^.server_count;
      IFEND;
      IF (nac$tcpip_application IN type_of_applications) AND
            (old_file_header^.version = nac$application_file_version) THEN
        number_of_applications := number_of_applications + old_file_header^.tcpip_count;
      IFEND;

      IF (number_of_applications > 0) AND (number_of_applications <= UPPERBOUND (application_attributes)) THEN
        i := LOWERBOUND (application_attributes);
        IF nac$server_application IN type_of_applications THEN
          FOR j := 1 TO old_file_header^.server_count DO
            application_attributes [i].name := old_server_pointers^ [j].server;
            application_attributes [i].application_type := nac$server_application;
            i := i + 1;
          FOREND;
        IFEND;
        IF nac$client_application IN type_of_applications THEN
          FOR j := 1 TO old_file_header^.client_count DO
            application_attributes [i].name := old_client_pointers^ [j].client;
            application_attributes [i].application_type := nac$client_application;
            i := i + 1;
          FOREND;
        IFEND;
        IF (nac$tcpip_application IN type_of_applications) AND
              (old_file_header^.version = nac$application_file_version) THEN
          FOR j := 1 TO old_file_header^.tcpip_count DO
            application_attributes [i].name := old_tcpip_pointers^ [j].application;
            application_attributes [i].application_type := nac$tcpip_application;
            i := i + 1;
          FOREND;
        IFEND;

      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (status);
      IFEND;
    IFEND;

  PROCEND nap$get_application_names;
?? TITLE := '[XDCL, #GATE] nap$get_application_type', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_application_type
    (    application: nat$application_name;
     VAR application_type: nat$application_type;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$complete_client_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      server_attributes: ^nat$server_attributes,
      server_definition: ^nat$complete_server_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (application, server_attributes);
      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      IF server_attributes <> NIL THEN
        application_type := nac$server_application;
      ELSE
        nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
        nap$find_client_attributes (application, client_attributes);
        nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
        IF client_attributes <> NIL THEN
          application_type := nac$client_application;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
        IFEND;
      IFEND;
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_server_definition (application, old_application_file, server_definition);
      IF server_definition <> NIL THEN
        application_type := nac$server_application;
      ELSE
        find_client_definition (application, old_application_file, client_definition);
        IF client_definition <> NIL THEN
          application_type := nac$client_application;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
        IFEND;
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$get_application_type;
?? TITLE := '[XDCL, #GATE] nap$get_client_status', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_client_status
    (    client: nat$application_name;
     VAR client_status: nat$application_status;
     VAR reserved_application_id: boolean;
     VAR application_id: nat$internet_sap_identifier;
     VAR active_connection_count: nat$number_of_connections;
     VAR attempted_connection_count: integer;
     VAR rejected_connection_attempts: integer;
     VAR status: ost$status);


    VAR
      client_attributes: ^nat$client_attributes;

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

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
    nap$find_client_attributes (client, client_attributes);
    IF client_attributes = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
    ELSE
      nlp$get_nonexclusive_access (client_attributes^.access_control);
      client_status := client_attributes^.client_status;
      reserved_application_id := client_attributes^.reserved_application_id;
      application_id := client_attributes^.application_id.xns_sap_identifier;
      active_connection_count := client_attributes^.connection_count;
      attempted_connection_count := client_attributes^.attempted_connection_count;
      rejected_connection_attempts := client_attributes^.rejected_connection_attempts;
      nlp$release_nonexclusive_access (client_attributes^.access_control);
    IFEND;

    nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$get_client_status;
?? TITLE := '[XDCL, #GATE] nap$get_client_attributes', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_client_attributes
    (    client: nat$application_name;
     VAR client_status: nat$application_status;
     VAR max_connections: nat$number_of_connections;
     VAR connection_priority: nat$network_message_priority;
     VAR protocol: nat$protocol;
     VAR reserved_application_id: boolean;
     VAR application_id: nat$internet_sap_identifier;
     VAR client_capability: ost$name;
     VAR client_ring: ost$ring;
     VAR client_system_privilege: boolean;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$client_definition,
      complete_client_definition: ^nat$complete_client_definition,
      converted_client_definition: ^nat$complete_client_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
      nap$find_client_attributes (client, client_attributes);
      IF client_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
      ELSE
        nlp$get_nonexclusive_access (client_attributes^.access_control);
        client_status := client_attributes^.client_status;
        max_connections := client_attributes^.max_connections;
        connection_priority := client_attributes^.message_priority;
        protocol := client_attributes^.protocol;
        reserved_application_id := client_attributes^.reserved_application_id;
        IF reserved_application_id THEN
          application_id := client_attributes^.application_id.xns_sap_identifier;
        IFEND;
        client_capability := client_attributes^.client_capability;
        client_ring := client_attributes^.client_ring;
        client_system_privilege := client_attributes^.client_system_privilege;
        nlp$release_nonexclusive_access (client_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;

    ELSE

{ NAMVE is not active.

      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_client_definition (client, old_application_file, complete_client_definition);
      IF complete_client_definition = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, client, status);
      ELSE
        IF (old_file_header^.version = nac$application_file_version) OR
              (old_file_header^.version = nac$v11_appl_file_version) THEN
          NEXT client_definition IN complete_client_definition;
        ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
          convert_v10_client_to_v11 (complete_client_definition, converted_client_definition);
          RESET converted_client_definition;
          NEXT client_definition IN converted_client_definition;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
                status);
        IFEND;
        IF status.normal THEN
          client_status := client_definition^.client_status;
          max_connections := client_definition^.max_connections;
          connection_priority := client_definition^.message_priority;
          protocol := client_definition^.protocol;
          reserved_application_id := client_definition^.reserved_application_id;
          IF reserved_application_id THEN
            application_id := client_definition^.application_id;
          IFEND;
          client_capability := client_definition^.client_capability;
          client_ring := client_definition^.client_ring;
          client_system_privilege := client_definition^.client_system_privilege;
          IF old_file_header^.version = nac$v10_appl_file_version THEN
            FREE converted_client_definition IN osv$task_private_heap^;
          IFEND;
        IFEND;
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$get_client_attributes;
?? TITLE := '[XDCL, #GATE] nap$get_server_attributes', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_server_attributes
    (    server: nat$application_name;
     VAR server_status: nat$application_status;
     VAR selected_title_count: nat$max_titles;
         selected_titles: ^nat$selected_titles_list;
     VAR server_managed_title_count: nat$max_titles;
         server_managed_titles: ^nat$title_pattern_list;
     VAR max_connections: nat$number_of_connections;
     VAR connection_priority: nat$network_message_priority;
     VAR server_capability: ost$name;
     VAR server_ring: ost$ring;
     VAR server_system_privilege: boolean;
     VAR accept_connection: boolean;
     VAR client_validation_capability: ost$name;
     VAR client_info_source: nat$client_info_source;
     VAR client_address_count: integer;
         client_addresses: ^array [1 .. * ] of nat$client_address;
     VAR reserved_application_id: boolean;
     VAR application_id: nat$internet_sap_identifier;
     VAR protocol: nat$protocol;
     VAR nam_initiated_server: boolean;
     VAR server_job_validation_source: nat$server_validation_source;
     VAR server_job_max_connections: nat$number_of_connections;
     VAR server_job_specified: boolean;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_address_list: ^array [1 .. * ] of nat$client_address,
      complete_server_definition: ^nat$complete_server_definition,
      converted_server_definition: ^nat$complete_server_definition,
      i: integer,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      selected_titles_list: ^nat$selected_titles_list,
      server_attributes: ^nat$server_attributes,
      server_definition: ^nat$server_definition,
      server_managed_titles_list: ^nat$title_pattern_list;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
      nap$find_server_attributes (server, server_attributes);
      IF server_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSE
        nlp$get_nonexclusive_access (server_attributes^.access_control);
        IF server_attributes^.server_titles <> NIL THEN
          selected_title_count := UPPERBOUND (server_attributes^.server_titles^);
          IF selected_title_count <= UPPERBOUND (selected_titles^) THEN
            FOR i := 1 TO selected_title_count DO
              selected_titles^ [i].title := server_attributes^.server_titles^ [i].title;
              selected_titles^ [i].distribute_title := server_attributes^.server_titles^ [i].distribute_title;
              selected_titles^ [i].priority := server_attributes^.server_titles^ [i].priority;
              selected_titles^ [i].data := server_attributes^.server_titles^ [i].data;
              selected_titles^ [i].data_length := server_attributes^.server_titles^ [i].data_length;
            FOREND;
          IFEND;
        ELSE
          selected_title_count := 0;
        IFEND;

        IF server_attributes^.server_managed_titles <> NIL THEN
          server_managed_title_count := UPPERBOUND (server_attributes^.server_managed_titles^);
          IF server_managed_title_count <= UPPERBOUND (server_managed_titles^) THEN
            FOR i := 1 TO server_managed_title_count DO
              server_managed_titles^ [i] := server_attributes^.server_managed_titles^ [i];
            FOREND;
          IFEND;
        ELSE
          server_managed_title_count := 0;
        IFEND;

        IF server_attributes^.client_addresses <> NIL THEN
          client_address_count := UPPERBOUND (server_attributes^.client_addresses^);
          IF client_address_count <= UPPERBOUND (client_addresses^) THEN
            FOR i := 1 TO client_address_count DO
              client_addresses^ [i] := server_attributes^.client_addresses^ [i];
            FOREND;
          IFEND;
        ELSE
          client_address_count := 0;
        IFEND;

        server_status := server_attributes^.server_status;
        max_connections := server_attributes^.max_connections;
        connection_priority := server_attributes^.message_priority;
        server_capability := server_attributes^.server_capability;
        server_ring := server_attributes^.server_ring;
        server_system_privilege := server_attributes^.server_system_privilege;
        accept_connection := server_attributes^.accept_connection;
        client_validation_capability := server_attributes^.client_validation_capability;
        client_info_source := server_attributes^.client_info_source;
        reserved_application_id := server_attributes^.reserved_application_id;
        IF reserved_application_id THEN
          application_id := server_attributes^.application_id.xns_sap_identifier;
        IFEND;
        protocol := server_attributes^.protocol;
        nam_initiated_server := server_attributes^.nam_initiated_server;
        IF nam_initiated_server THEN
          server_job_validation_source := server_attributes^.server_job_validation_source;
          server_job_max_connections := server_attributes^.server_job_max_connections;
          server_job_specified := server_attributes^.service_file_defined;
        IFEND;
        nlp$release_nonexclusive_access (server_attributes^.access_control);
      IFEND;

      nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE

{ NAMVE is not active.

      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;
      find_server_definition (server, old_application_file, complete_server_definition);
      IF complete_server_definition = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSE
        IF (old_file_header^.version = nac$application_file_version) OR
              (old_file_header^.version = nac$v11_appl_file_version) THEN
          NEXT server_definition IN complete_server_definition;
        ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
          convert_v10_server_to_v11 (complete_server_definition, converted_server_definition);
          RESET converted_server_definition;
          NEXT server_definition IN converted_server_definition;
        ELSE
          osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
                status);
        IFEND;
        IF status.normal THEN
          selected_title_count := server_definition^.title_count;
          IF selected_title_count > 0 THEN
            IF (old_file_header^.version = nac$application_file_version) OR
                  (old_file_header^.version = nac$v11_appl_file_version) THEN
              selected_titles_list := #PTR (server_definition^.selected_titles, complete_server_definition^);
            ELSE
              selected_titles_list := #PTR (server_definition^.selected_titles, converted_server_definition^);
            IFEND;
            IF selected_title_count <= UPPERBOUND (selected_titles^) THEN
              FOR i := 1 TO selected_title_count DO
                selected_titles^ [i] := selected_titles_list^ [i];
              FOREND;
            IFEND;
          IFEND;

          server_managed_title_count := server_definition^.server_managed_title_count;
          IF server_managed_title_count > 0 THEN
            IF (old_file_header^.version = nac$application_file_version) OR
                  (old_file_header^.version = nac$v11_appl_file_version) THEN
              server_managed_titles_list := #PTR (server_definition^.server_managed_titles,
                    complete_server_definition^);
            ELSE
              server_managed_titles_list := #PTR (server_definition^.server_managed_titles,
                    converted_server_definition^);
            IFEND;
            IF server_managed_title_count <= UPPERBOUND (server_managed_titles^) THEN
              FOR i := 1 TO server_managed_title_count DO
                server_managed_titles^ [i] := server_managed_titles_list^ [i];
              FOREND;
            IFEND;
          IFEND;

          client_address_count := server_definition^.client_address_count;
          IF client_address_count > 0 THEN
            IF (old_file_header^.version = nac$application_file_version) OR
                  (old_file_header^.version = nac$v11_appl_file_version) THEN
              client_address_list := #PTR (server_definition^.client_addresses, complete_server_definition^);
            ELSE
              client_address_list := #PTR (server_definition^.client_addresses, converted_server_definition^);
            IFEND;
            IF client_address_count <= UPPERBOUND (client_addresses^) THEN
              FOR i := 1 TO client_address_count DO
                client_addresses^ [i] := client_address_list^ [i];
              FOREND;
            IFEND;
          IFEND;

          server_status := server_definition^.server_status;
          max_connections := server_definition^.max_connections;
          connection_priority := server_definition^.message_priority;
          server_capability := server_definition^.server_capability;
          server_ring := server_definition^.server_ring;
          server_system_privilege := server_definition^.server_system_privilege;
          accept_connection := server_definition^.accept_connection;
          client_validation_capability := server_definition^.client_validation_capability;
          client_info_source := server_definition^.client_info_source;
          reserved_application_id := server_definition^.reserved_application_id;
          IF reserved_application_id THEN
            application_id := server_definition^.application_id;
          IFEND;
          protocol := server_definition^.protocol;
          nam_initiated_server := server_definition^.nam_initiated_server;
          IF nam_initiated_server THEN
            server_job_validation_source := server_definition^.server_job_validation_source;
            server_job_max_connections := server_definition^.server_job_max_connections;
            server_job_specified := server_definition^.service_file_defined;
          IFEND;
          IF old_file_header^.version = nac$v10_appl_file_version THEN
            FREE converted_server_definition IN osv$task_private_heap^;
          IFEND;
        IFEND;
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$get_server_attributes;
?? TITLE := '[XDCL, #GATE] nap$get_server_status', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_server_status
    (    server: nat$application_name;
     VAR server_status: nat$application_status;
     VAR reserved_application_id: boolean;
     VAR application_id: nat$internet_sap_identifier;
     VAR active_job_count: integer;
     VAR display_job_attributes: array [1 .. * ] of nat$display_job_attributes;
     VAR active_connection_count: nat$number_of_connections;
     VAR attempted_connection_count: integer;
     VAR rejected_connection_attempts: integer;
     VAR server_managed_title_count: nat$max_titles;
     VAR server_managed_titles: array [1 .. * ] of string (nac$max_title_pattern_length);
     VAR status: ost$status);


    VAR
      added_title: ^nat$added_title,
      added_title_count: integer,
      i: integer,
      server_attributes: ^nat$server_attributes,
      server_job_attributes: ^nat$server_job_attributes;

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

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
    nap$find_server_attributes (server, server_attributes);
    IF server_attributes = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
    ELSE
      nlp$get_nonexclusive_access (server_attributes^.access_control);
      server_status := server_attributes^.server_status;
      active_job_count := 0;
      server_job_attributes := server_attributes^.server_job_list;
      WHILE server_job_attributes <> NIL DO
        active_job_count := active_job_count + 1;
        IF active_job_count <= UPPERBOUND (display_job_attributes) THEN
          display_job_attributes [active_job_count].job_name := server_job_attributes^.job_name;
          display_job_attributes [active_job_count].connection_count :=
                server_job_attributes^.connection_count;
        IFEND;
        server_job_attributes := server_job_attributes^.next_entry;
      WHILEND;
      active_connection_count := server_attributes^.connection_count;
      attempted_connection_count := server_attributes^.attempted_connection_count;
      rejected_connection_attempts := server_attributes^.rejected_connection_attempts;
      added_title_count := 0;
      added_title := server_attributes^.added_titles;
      WHILE added_title <> NIL DO
        added_title_count := added_title_count + 1;
        IF added_title_count <= UPPERBOUND (server_managed_titles) THEN
          server_managed_titles [added_title_count] := added_title^.title;
        IFEND;
        added_title := added_title^.next_title;
      WHILEND;
      server_managed_title_count := added_title_count;
      nlp$release_nonexclusive_access (server_attributes^.access_control);
    IFEND;

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$get_server_status;
?? TITLE := '[XDCL, #GATE] nap$get_tcpip_attributes', EJECT ??
*copyc nah$get_tcpip_attributes

  PROCEDURE [XDCL, #GATE] nap$get_tcpip_attributes
    (    application: nat$application_name;
     VAR tcpip_status: nat$application_status;
     VAR maximum_sockets: nat$number_of_sockets;
     VAR tcpip_capability: ost$name;
     VAR tcpip_ring: ost$ring;
     VAR tcpip_system_privilege: boolean;
     VAR protocol: nat$protocol;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      complete_tcpip_definition: ^nat$complete_tcpip_definition,
      local_status: ost$status,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcpip_definition: ^nat$tcpip_definition;

    status.normal := TRUE;
    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      nap$find_tcpip_attributes (application, tcpip_attributes);
      IF tcpip_attributes = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSE
        nlp$get_nonexclusive_access (tcpip_attributes^.access_control);
        tcpip_status := tcpip_attributes^.tcpip_status;
        maximum_sockets := tcpip_attributes^.maximum_sockets;
        protocol := tcpip_attributes^.protocol;
        tcpip_capability := tcpip_attributes^.tcpip_capability;
        tcpip_ring := tcpip_attributes^.tcpip_ring;
        tcpip_system_privilege := tcpip_attributes^.tcpip_system_privilege;
        nlp$release_nonexclusive_access (tcpip_attributes^.access_control);
      IFEND;
      nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE {NAMVE is not active.
      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      find_tcpip_definition (application, old_application_file, complete_tcpip_definition);
      IF complete_tcpip_definition = NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      ELSE
        NEXT tcpip_definition IN complete_tcpip_definition;
        IF status.normal THEN
          tcpip_status := tcpip_definition^.tcpip_status;
          maximum_sockets := tcpip_definition^.maximum_sockets;
          protocol := tcpip_definition^.protocol;
          tcpip_capability := tcpip_definition^.tcpip_capability;
          tcpip_ring := tcpip_definition^.tcpip_ring;
          tcpip_system_privilege := tcpip_definition^.tcpip_system_privilege;
        IFEND;
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;
  PROCEND nap$get_tcpip_attributes;
?? TITLE := '[XDCL, #GATE] nap$get_tcpip_status', EJECT ??
*copyc nah$get_tcpip_status

  PROCEDURE [XDCL, #GATE] nap$get_tcpip_status
    (    application: nat$application_name;
     VAR tcpip_status: nat$application_status;
     VAR active_socket_count: nat$number_of_sockets;
     VAR socket_attempt_count: integer;
     VAR socket_reject_count: integer;
     VAR status: ost$status);

    VAR
      tcpip_attributes: ^nat$tcpip_attributes;

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

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
    nap$find_tcpip_attributes (application, tcpip_attributes);
    IF tcpip_attributes = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
    ELSE
      nlp$get_nonexclusive_access (tcpip_attributes^.access_control);
      tcpip_status := tcpip_attributes^.tcpip_status;
      active_socket_count := tcpip_attributes^.active_socket_count;
      socket_attempt_count := tcpip_attributes^.socket_attempt_count;
      socket_reject_count := tcpip_attributes^.socket_reject_count;
      nlp$release_nonexclusive_access (tcpip_attributes^.access_control);
    IFEND;
    nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;
  PROCEND nap$get_tcpip_status;

?? TITLE := '[XDCL] nap$idle_network_applications', EJECT ??

  PROCEDURE [XDCL] nap$idle_network_applications
    (    terminate_inactive_applications: boolean;
     VAR status: ost$status);

{ PURPOSE:
{   The purpose of this procedure is to shut down all defined network applications
{   and release the associated allocated data structures.  This is done to prepare
{   for NAM/VE termination. This procedure is called within the system job.
{
{ METHOD:
{   Active applications are deactivated with all connections being terminated.
{   If terminate_inactive_applications is TRUE (which will be the case on the first
{   call), inactive applications are also re-deactivated in order to terminate any
{   remaining active connections.  When an application is inactive and idle, the
{   table entry defining the application is deleted.  This procedure returns after
{   making one pass through all of the application definition tables.  Normal status
{   is returned when all application definitions have been deleted.

    VAR
      client_attributes: ^nat$client_attributes,
      i: integer,
      ignore_status: ost$status,
      server_attributes: ^nat$server_attributes,
      previous_client_attributes: ^^nat$client_attributes,
      previous_server_attributes: ^^nat$server_attributes,
      previous_tcpip_attributes: ^^nat$tcpip_attributes,
      protocol: nat$protocol,
      tcpip_application: nat$application_name,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcp_socket: ^nat$tcp_socket,
      tcp_socket_list: ^array [1 .. * ] of nat$tcp_socket,
      udp_socket: ^nat$udp_socket,
      udp_socket_list: ^array [1 .. * ] of nat$udp_socket,
      wait_for_connection: ^nat$wait_for_connection;

    status.normal := TRUE;
    nlp$get_exclusive_access (nav$server_attributes_list.access_control);
    server_attributes := nav$server_attributes_list.server_attributes;
    previous_server_attributes := ^nav$server_attributes_list.server_attributes;

    WHILE (server_attributes <> NIL) DO
      IF terminate_inactive_applications OR (server_attributes^.server_status <> nac$application_inactive)
            THEN
        deactivate_server (server_attributes, {terminate_active_connections = } TRUE);
        server_attributes^.server_status := nac$application_inactive;
      IFEND;

{ Ready the server tasks waiting for a connection.

      wait_for_connection := server_attributes^.wait_for_connection;
      WHILE wait_for_connection <> NIL DO
        pmp$ready_task (wait_for_connection^.task_id, ignore_status);
        wait_for_connection := wait_for_connection^.next_entry;
      WHILEND;

      IF (server_attributes^.connection_count = 0) AND (server_attributes^.server_job_list = NIL) AND
            (server_attributes^.wait_for_connection = NIL) THEN
        previous_server_attributes^ := server_attributes^.next_entry;
        free_server_attributes_entry (server_attributes);
      ELSE
        previous_server_attributes := ^server_attributes^.next_entry;
      IFEND;

      server_attributes := previous_server_attributes^;
    WHILEND;
    nlp$release_exclusive_access (nav$server_attributes_list.access_control);

    nlp$get_exclusive_access (nav$client_attributes_list.access_control);
    client_attributes := nav$client_attributes_list.client_attributes;
    previous_client_attributes := ^nav$client_attributes_list.client_attributes;

    WHILE (client_attributes <> NIL) DO
      IF terminate_inactive_applications OR (client_attributes^.client_status <> nac$application_inactive)
            THEN
        deactivate_client (client_attributes, {terminate_active_connections = } TRUE);
        client_attributes^.client_status := nac$application_inactive;
      IFEND;

      IF (client_attributes^.connection_count = 0) THEN
        previous_client_attributes^ := client_attributes^.next_entry;
        FREE client_attributes IN nav$network_paged_heap^;
      ELSE
        previous_client_attributes := ^client_attributes^.next_entry;
      IFEND;

      client_attributes := previous_client_attributes^;
    WHILEND;
    nlp$release_exclusive_access (nav$client_attributes_list.access_control);

    nlp$get_exclusive_access (nav$tcpip_attributes_list.access_control);
    tcpip_attributes := nav$tcpip_attributes_list.tcpip_attributes;
    previous_tcpip_attributes := ^nav$tcpip_attributes_list.tcpip_attributes;

    WHILE (tcpip_attributes <> NIL) DO
      IF terminate_inactive_applications OR (tcpip_attributes^.tcpip_status <> nac$application_inactive) THEN
        tcp_socket_list := NIL;
        udp_socket_list := NIL;
        tcpip_application := tcpip_attributes^.tcpip_application;
        protocol := tcpip_attributes^.protocol;
        IF (tcpip_attributes^.protocol = nac$stream_socket) AND
              (tcpip_attributes^.active_socket_count > 0) THEN
          PUSH tcp_socket_list: [1 .. tcpip_attributes^.active_socket_count];
          i := 1;
          tcp_socket := tcpip_attributes^.tcp_socket_list;
          WHILE tcp_socket <> NIL DO
            tcp_socket_list^ [i] := tcp_socket^;
            i := i + 1;
            tcp_socket := tcp_socket^.next_entry;
          WHILEND;
        ELSEIF (tcpip_attributes^.protocol = nac$datagram_socket) AND
              (tcpip_attributes^.active_socket_count <> 0) THEN
          PUSH udp_socket_list: [1 .. tcpip_attributes^.active_socket_count];
          i := 1;
          udp_socket := tcpip_attributes^.udp_socket_list;
          WHILE udp_socket <> NIL DO
            udp_socket_list^ [i] := udp_socket^;
            i := i + 1;
            udp_socket := udp_socket^.next_entry;
          WHILEND;
        IFEND;
        tcpip_attributes^.tcpip_status := nac$application_inactive;
        nlp$release_exclusive_access (nav$tcpip_attributes_list.access_control);
        deactivate_tcpip (tcpip_application, protocol, {terminate_active_connections = } TRUE,
              tcp_socket_list, udp_socket_list);
        nlp$get_exclusive_access (nav$tcpip_attributes_list.access_control);
        previous_tcpip_attributes := ^nav$tcpip_attributes_list.tcpip_attributes;
        WHILE (previous_tcpip_attributes^ <> NIL) AND (previous_tcpip_attributes^ <> tcpip_attributes) DO
          previous_tcpip_attributes := ^previous_tcpip_attributes^^.next_entry;
        WHILEND;
        IF previous_tcpip_attributes^ <> NIL THEN
          previous_tcpip_attributes := ^previous_tcpip_attributes^^.next_entry;
        IFEND;
      ELSEIF (tcpip_attributes^.active_socket_count = 0) THEN
        previous_tcpip_attributes^ := tcpip_attributes^.next_entry;
        FREE tcpip_attributes IN nav$network_paged_heap^;
      ELSE
        previous_tcpip_attributes := ^tcpip_attributes^.next_entry;
      IFEND;

      tcpip_attributes := previous_tcpip_attributes^;
    WHILEND;
    nlp$release_exclusive_access (nav$tcpip_attributes_list.access_control);

    IF (nav$server_attributes_list.server_attributes <> NIL) OR
          (nav$client_attributes_list.client_attributes <> NIL) OR
          (nav$tcpip_attributes_list.tcpip_attributes <> NIL) THEN
      osp$set_status_condition (nae$network_applications_active, status);
    ELSE
      nav$applications_installed := FALSE;
    IFEND;

  PROCEND nap$idle_network_applications;
?? TITLE := '[XDCL] nap$initialize_application_defn', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to setup the nam application definitions in
{   the network paged segment. The application file is attached for exclusive
{   access and the definitions are copied into the network paged segment. This
{   procedure is called within the system job.

  PROCEDURE [XDCL] nap$initialize_application_defn
    (VAR status: ost$status);

    VAR
      file_header: ^nat$application_file_header,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$client_definition,
      client_pointers: ^nat$client_pointers,
      complete_client_definition: ^nat$complete_client_definition,
      complete_server_definition: ^nat$complete_server_definition,
      complete_tcpip_definition: ^nat$complete_tcpip_definition,
      converted_client_definition: ^nat$complete_client_definition,
      converted_server_definition: ^nat$complete_server_definition,
      i: integer,
      local_status: ost$status,
      old_client_attributes: ^nat$client_attributes,
      old_server_attributes: ^nat$server_attributes,
      old_tcpip_attributes: ^nat$tcpip_attributes,
      previous_client_attributes: ^^nat$client_attributes,
      previous_server_attributes: ^^nat$server_attributes,
      previous_tcpip_attributes: ^^nat$tcpip_attributes,
      server_attributes: ^nat$server_attributes,
      server_definition: ^nat$server_definition,
      server_pointers: ^nat$server_pointers,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcpip_definition: ^nat$tcpip_definition,
      tcpip_pointers: ^nat$tcpip_pointers,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    status.normal := TRUE;
    nap$attach_application_file (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    RESET old_application_file;
    NEXT file_header IN old_application_file;
    IF file_header^.version <> nac$application_file_version THEN
      RESET old_application_file;
      NEXT v10_v11_file_header IN old_application_file;
    IFEND;
    IF file_header^.server_count > 0 THEN
      NEXT server_pointers: [1 .. file_header^.server_count] IN old_application_file;
    IFEND;
    IF file_header^.client_count > 0 THEN
      NEXT client_pointers: [1 .. file_header^.client_count] IN old_application_file;
    IFEND;
    IF file_header^.version = nac$application_file_version THEN
      IF file_header^.tcpip_count > 0 THEN
        NEXT tcpip_pointers: [1 .. file_header^.tcpip_count] IN old_application_file;
      IFEND;
    IFEND;

    IF file_header^.server_count > 0 THEN
      nlp$get_exclusive_access (nav$server_attributes_list.access_control);
      previous_server_attributes := ^nav$server_attributes_list.server_attributes;

      FOR i := 1 TO file_header^.server_count DO
        complete_server_definition := #PTR (server_pointers^ [i].pointer, old_application_file^);
        IF (file_header^.version = nac$application_file_version) OR
              (file_header^.version = nac$v11_appl_file_version) THEN
          define_server_attributes_entry (complete_server_definition, server_attributes);
        ELSEIF file_header^.version = nac$v10_appl_file_version THEN
          convert_v10_server_to_v11 (complete_server_definition, converted_server_definition);
          define_server_attributes_entry (converted_server_definition, server_attributes);
          FREE converted_server_definition IN osv$task_private_heap^;
        IFEND;

        nap$find_server_attributes (server_attributes^.server, old_server_attributes);
        IF old_server_attributes = NIL THEN
          previous_server_attributes^ := server_attributes;
          previous_server_attributes := ^server_attributes^.next_entry;
        ELSE
          old_server_attributes^.server_status := server_attributes^.server_status;
          free_server_attributes_entry (server_attributes);
          server_attributes := old_server_attributes;
        IFEND;

        IF (server_attributes^.nam_initiated_server) AND (server_attributes^.server_status =
              nac$application_active) THEN
          activate_server (server_attributes, local_status);
          IF NOT local_status.normal THEN
            server_attributes^.server_status := nac$application_inactive;
            nap$display_message (local_status);
            osp$set_status_abnormal (nac$status_id, nae$unable_to_activate_appl, server_attributes^.server,
                  local_status);
            nap$display_message (local_status);
          IFEND;
        IFEND;
      FOREND;

      nlp$release_exclusive_access (nav$server_attributes_list.access_control);
    IFEND;

    IF file_header^.client_count > 0 THEN
      nlp$get_exclusive_access (nav$client_attributes_list.access_control);
      previous_client_attributes := ^nav$client_attributes_list.client_attributes;

      FOR i := 1 TO file_header^.client_count DO
        complete_client_definition := #PTR (client_pointers^ [i].pointer, old_application_file^);
        IF (file_header^.version = nac$application_file_version) OR
              (file_header^.version = nac$v11_appl_file_version) THEN
          RESET complete_client_definition;
          NEXT client_definition IN complete_client_definition;
          define_client_attributes_entry (client_definition, client_attributes);
        ELSEIF file_header^.version = nac$v10_appl_file_version THEN
          convert_v10_client_to_v11 (complete_client_definition, converted_client_definition);
          RESET converted_client_definition;
          NEXT client_definition IN converted_client_definition;
          define_client_attributes_entry (client_definition, client_attributes);
          FREE converted_client_definition IN osv$task_private_heap^;
        IFEND;
        nap$find_client_attributes (client_attributes^.client, old_client_attributes);
        IF old_client_attributes = NIL THEN
          previous_client_attributes^ := client_attributes;
          previous_client_attributes := ^client_attributes^.next_entry;
        ELSE
          old_client_attributes^.client_status := client_attributes^.client_status;
          FREE client_attributes IN nav$network_paged_heap^;
          client_attributes := old_client_attributes;
        IFEND;
        IF client_attributes^.client_status = nac$application_active THEN
          activate_client (client_attributes, local_status);
          IF NOT local_status.normal THEN
            client_attributes^.client_status := nac$application_inactive;
            nap$display_message (local_status);
            osp$set_status_abnormal (nac$status_id, nae$unable_to_activate_appl, client_attributes^.client,
                  local_status);
            nap$display_message (local_status);
          IFEND;
        IFEND;
      FOREND;
      nlp$release_exclusive_access (nav$client_attributes_list.access_control);
    IFEND;

    IF file_header^.version = nac$application_file_version THEN
      IF file_header^.tcpip_count > 0 THEN
        nlp$get_exclusive_access (nav$tcpip_attributes_list.access_control);
        previous_tcpip_attributes := ^nav$tcpip_attributes_list.tcpip_attributes;

        FOR i := 1 TO file_header^.tcpip_count DO
          complete_tcpip_definition := #PTR (tcpip_pointers^ [i].pointer, old_application_file^);
          RESET complete_tcpip_definition;
          NEXT tcpip_definition IN complete_tcpip_definition;
          define_tcpip_attributes_entry (tcpip_definition, tcpip_attributes);
          nap$find_tcpip_attributes (tcpip_attributes^.tcpip_application, old_tcpip_attributes);
          IF old_tcpip_attributes = NIL THEN
            previous_tcpip_attributes^ := tcpip_attributes;
            previous_tcpip_attributes := ^tcpip_attributes^.next_entry;
          ELSE
            old_tcpip_attributes^.tcpip_status := tcpip_attributes^.tcpip_status;
            FREE tcpip_attributes IN nav$network_paged_heap^;
          IFEND;
        FOREND;
        nlp$release_exclusive_access (nav$tcpip_attributes_list.access_control);
      IFEND;
    IFEND;
    nav$applications_installed := TRUE;
    nav$appl_defn_time_stamp := file_header^.modification_date_time;
    nap$detach_application_file (status);

  PROCEND nap$initialize_application_defn;
?? TITLE := '[XDCL, #GATE] nap$open_server_job_file', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to attach and open the job definition
{   file for the given server for read access.

  PROCEDURE [XDCL, #GATE] nap$open_server_job_file
    (    server: nat$application_name;
     VAR server_file_identifier: amt$file_identifier;
     VAR status: ost$status);

?? NEWTITLE := '    handle_block_exit', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to deal with block exit conditions that
{   arise while system_authority is in effect.

    PROCEDURE handle_block_exit
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           sfsa_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      pfp$end_system_authority;
      osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
      nap$condition_handler_trace (condition, sfsa_p);
    PROCEND handle_block_exit;

?? OLDTITLE, EJECT ??


    VAR
      file_name: clt$file,
      job_file_path: array [1 .. 6] of pft$name,
      job_file_path_string: fst$path,
      path_size: fst$path_size;

    verify_appl_mgmt_capability (status);
    IF status.normal THEN
      job_file_path := application_job_file_path;
      job_file_path [UPPERBOUND (job_file_path)] := server;
      pfp$convert_pft$path_to_fs_path (job_file_path, job_file_path_string, path_size);
      clp$convert_string_to_file (job_file_path_string (1, path_size), file_name, status);
      IF status.normal THEN
        osp$establish_block_exit_hndlr (^handle_block_exit);
        pfp$begin_system_authority;
        fsp$open_file (file_name.local_file_name, amc$record, ^job_file_access_selections,
              {default_creation_attributes=} NIL, {mandated_creation_attributes=} NIL,
              {attribute_validation=} NIL, {attributes_override=} NIL, server_file_identifier, status);
        pfp$end_system_authority;
        osp$disestablish_cond_handler;
      IFEND;
    IFEND;
  PROCEND nap$open_server_job_file;
?? TITLE := '[XDCL] nap$process_job_termination', EJECT ??

{  PURPOSE:
{    The purpose of this procedure is to detach the currently executing job from
{    all known applications.
{    In addition, nap$gt_process_job_termination is called to close all saps
{    opened within the terminating job.

  PROCEDURE [XDCL] nap$process_job_termination;

    VAR
      executing_job_name: jmt$system_supplied_name,
      ignore_status: ost$status,
      previous_server_job_attributes: ^^nat$server_job_attributes,
      previous_wait_for_connection: ^^nat$wait_for_connection,
      server_attributes: ^nat$server_attributes,
      server_job_attributes: ^nat$server_job_attributes,
      status: ost$status,
      wait_for_connection: ^nat$wait_for_connection,
      user_supplied_name: jmt$user_supplied_name;


    pmp$get_job_names (user_supplied_name, executing_job_name, ignore_status);
    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
    server_attributes := nav$server_attributes_list.server_attributes;

    WHILE server_attributes <> NIL DO
      nlp$get_exclusive_access (server_attributes^.access_control);

{ Remove the task from the wait for connection queue.

      IF server_attributes^.wait_for_connection <> NIL THEN
        previous_wait_for_connection := ^server_attributes^.wait_for_connection;
        wait_for_connection := server_attributes^.wait_for_connection;
        WHILE (wait_for_connection <> NIL) AND (wait_for_connection^.job_name <> executing_job_name) DO
          previous_wait_for_connection := ^wait_for_connection^.next_entry;
          wait_for_connection := wait_for_connection^.next_entry;
        WHILEND;
        IF wait_for_connection <> NIL THEN
          previous_wait_for_connection^ := wait_for_connection^.next_entry;
          FREE wait_for_connection IN nav$network_paged_heap^;
{ *** DEBUG pmp$log ('AM - Task removed from wait for conn q.', ignore_status);
        IFEND;
      IFEND;

{ Detach the job from the server.
      server_job_attributes := server_attributes^.server_job_list;
      previous_server_job_attributes := ^server_attributes^.server_job_list;

      WHILE (server_job_attributes <> NIL) AND (server_job_attributes^.job_name <> executing_job_name) DO
        previous_server_job_attributes := ^server_job_attributes^.next_entry;
        server_job_attributes := server_job_attributes^.next_entry;
      WHILEND;

      IF server_job_attributes <> NIL THEN
        IF server_job_attributes^.connection_count > 0 THEN
          nap$namve_system_error (TRUE, 'Job terminating with active server connections.', NIL);
        IFEND;

        previous_server_job_attributes^ := server_job_attributes^.next_entry;
        FREE server_job_attributes IN nav$network_paged_heap^;
        IF (NOT server_attributes^.nam_initiated_server) AND (server_attributes^.server_job_list = NIL) AND
              (server_attributes^.protocol_activated) THEN
          deactivate_server (server_attributes, FALSE);
        IFEND;
      IFEND;

      nlp$release_exclusive_access (server_attributes^.access_control);
      server_attributes := server_attributes^.next_entry;
    WHILEND;

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);

    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;
    nap$gt_process_job_termination;
    nap$sk_process_job_termination;

  PROCEND nap$process_job_termination;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nap$set_server_job_init_pending', EJECT ??

  PROCEDURE [XDCL] nap$set_server_job_init_pending
    (    server: nat$application_name;
         server_job_init_pending: boolean;
     VAR status: ost$status);

    VAR
      server_attributes: ^nat$server_attributes;

    status.normal := TRUE;

    osp$push_inhibit_job_recovery;
    osp$begin_subsystem_activity;
    nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
    nap$find_server_attributes (server, server_attributes);
    IF server_attributes = NIL THEN
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
    ELSE
      nlp$get_exclusive_access (server_attributes^.access_control);
      nap$validate_user (server_attributes^.server_capability, server_attributes^.server_ring,
            server_attributes^.server_system_privilege, status);
      IF NOT status.normal THEN
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, server, status);
      ELSEIF server_attributes^.server_status = nac$application_inactive THEN
        osp$set_status_abnormal (nac$status_id, nae$application_inactive, server, status);
      ELSE
        server_attributes^.server_job_init_pending := server_job_init_pending;
      IFEND;
      nlp$release_exclusive_access (server_attributes^.access_control);
    IFEND;

    nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
    osp$end_subsystem_activity;
    osp$pop_inhibit_job_recovery;

  PROCEND nap$set_server_job_init_pending;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$verify_application_id', EJECT ??

{ PURPOSE:
{   The purpose of this request is to verify that the given sap_id is unique
{   across all the reserved application identifiers selected for all the
{   defined servers and clients.

  PROCEDURE [XDCL, #GATE] nap$verify_application_id
    (    application_id: nat$internet_sap_identifier;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client: nat$application_name,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$client_definition,
      client_pointers: ^nat$client_pointers,
      complete_client_definition: ^nat$complete_client_definition,
      complete_server_definition: ^nat$complete_server_definition,
      i: integer,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      server: nat$application_name,
      server_attributes: ^nat$server_attributes,
      server_definition: ^nat$server_definition,
      server_pointers: ^nat$server_pointers,
      v10_client_definition: ^nat$v10_client_definition,
      v10_server_definition: ^nat$v10_server_definition,
      v10_v11_file_header: ^nat$v10_v11_file_header;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN

{ Scan the client attributes list.

      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);
      client_attributes := nav$client_attributes_list.client_attributes;

    /scan_defined_clients/
      WHILE client_attributes <> NIL DO
        IF (client_attributes^.reserved_application_id) AND
              (client_attributes^.application_id.xns_sap_identifier = application_id) THEN
          osp$set_status_condition (nae$conflicting_reserved_sap, status);
          osp$append_status_integer (osc$status_parameter_delimiter, application_id, 10, TRUE, status);
          EXIT /scan_defined_clients/; {----->
        IFEND;

        client_attributes := client_attributes^.next_entry;
      WHILEND /scan_defined_clients/;

      nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);

{ Scan server attributes list.

      IF status.normal THEN
        nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);
        server_attributes := nav$server_attributes_list.server_attributes;

      /scan_defined_servers/
        WHILE server_attributes <> NIL DO
          IF (server_attributes^.reserved_application_id) AND
                (server_attributes^.application_id.xns_sap_identifier = application_id) THEN
            osp$set_status_condition (nae$conflicting_reserved_sap, status);
            osp$append_status_integer (osc$status_parameter_delimiter, application_id, 10, TRUE, status);
            EXIT /scan_defined_servers/; {----->
          IFEND;

          server_attributes := server_attributes^.next_entry;
        WHILEND /scan_defined_servers/;

        nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      IFEND;
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;

    ELSE

{ NAMVE is not active.

      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;

      IF old_file_header^.version <> nac$application_file_version THEN
        RESET old_application_file;
        NEXT v10_v11_file_header IN old_application_file;
      IFEND;

{ Search the server definitions for a matching application identifier.

      IF old_file_header^.server_count > 0 THEN
        NEXT server_pointers: [1 .. old_file_header^.server_count] IN old_application_file;

      /search_servers/
        FOR i := 1 TO old_file_header^.server_count DO
          server := server_pointers^ [i].server;
          find_server_definition (server, old_application_file, complete_server_definition);
          IF complete_server_definition = NIL THEN
            osp$set_status_abnormal (nac$status_id, nae$application_file_error, verify_application_id,
                  status);
            EXIT /search_servers/; {----->
          IFEND;
          IF (old_file_header^.version = nac$application_file_version) OR
                (old_file_header^.version = nac$v11_appl_file_version) THEN
            NEXT server_definition IN complete_server_definition;
            IF (server_definition^.reserved_application_id) AND
                  (server_definition^.application_id = application_id) THEN
              osp$set_status_condition (nae$conflicting_reserved_sap, status);
              osp$append_status_integer (osc$status_parameter_delimiter, application_id, 10, TRUE, status);
              EXIT /search_servers/; {----->
            IFEND;
          ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
            NEXT v10_server_definition IN complete_server_definition;
            IF (v10_server_definition^.reserved_application_id) AND
                  (v10_server_definition^.application_id = application_id) THEN
              osp$set_status_condition (nae$conflicting_reserved_sap, status);
              osp$append_status_integer (osc$status_parameter_delimiter, application_id, 10, TRUE, status);
              EXIT /search_servers/; {----->
            IFEND;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version, old_file_header^.version,
                  status);
            EXIT /search_servers/; {----->
          IFEND;
        FOREND /search_servers/;
      IFEND;

      IF status.normal THEN

{ Search the client definitions for a matching application identifier.

        IF old_file_header^.client_count > 0 THEN
          NEXT client_pointers: [1 .. old_file_header^.client_count] IN old_application_file;

        /search_clients/
          FOR i := 1 TO old_file_header^.client_count DO
            client := client_pointers^ [i].client;
            find_client_definition (client, old_application_file, complete_client_definition);
            IF complete_client_definition = NIL THEN
              osp$set_status_abnormal (nac$status_id, nae$application_file_error, verify_application_id,
                    status);
              EXIT /search_clients/; {----->
            IFEND;
            IF (old_file_header^.version = nac$application_file_version) OR
                  (old_file_header^.version = nac$v11_appl_file_version) THEN
              NEXT client_definition IN complete_client_definition;
              IF (client_definition^.reserved_application_id) AND
                    (client_definition^.application_id = application_id) THEN
                osp$set_status_condition (nae$conflicting_reserved_sap, status);
                osp$append_status_integer (osc$status_parameter_delimiter, application_id, 10, TRUE, status);
                EXIT /search_clients/; {----->
              IFEND;
            ELSEIF old_file_header^.version = nac$v10_appl_file_version THEN
              NEXT v10_client_definition IN complete_client_definition;
              IF (v10_client_definition^.reserved_application_id) AND
                    (v10_client_definition^.application_id = application_id) THEN
                osp$set_status_condition (nae$conflicting_reserved_sap, status);
                osp$append_status_integer (osc$status_parameter_delimiter, application_id, 10, TRUE, status);
                EXIT /search_clients/; {----->
              IFEND;
            ELSE
              osp$set_status_abnormal (nac$status_id, nae$incorrect_appl_file_version,
                    old_file_header^.version, status);
              EXIT /search_clients/; {----->
            IFEND;
          FOREND /search_clients/;
        IFEND;
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$verify_application_id;
?? TITLE := '[XDCL, #GATE] nap$verify_application_name', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to verify that the given application name
{   is unqiue accross all defined server and client applications.

  PROCEDURE [XDCL, #GATE] nap$verify_application_name
    (    application: nat$application_name;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      client_attributes: ^nat$client_attributes,
      client_definition: ^nat$complete_client_definition,
      ignore_status: ost$status,
      local_status: ost$status,
      old_file_header: ^nat$application_file_header,
      server_definition: ^nat$complete_server_definition,
      server_attributes: ^nat$server_attributes;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$client_attributes_list.access_control);

{ Search for a matching client application name.

      nap$find_client_attributes (application, client_attributes);
      IF client_attributes <> NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$application_already_defined, client, status);
      IFEND;
      nlp$release_nonexclusive_access (nav$client_attributes_list.access_control);

      IF status.normal THEN
        nlp$get_nonexclusive_access (nav$server_attributes_list.access_control);

{ Search for a matching server application name.

        nap$find_server_attributes (application, server_attributes);
        IF server_attributes <> NIL THEN
          osp$set_status_abnormal (nac$status_id, nae$application_already_defined, server, status);
        IFEND;
        nlp$release_nonexclusive_access (nav$server_attributes_list.access_control);
      IFEND;
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE

{ NAMVE is not active.

      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

      RESET old_application_file;
      NEXT old_file_header IN old_application_file;

{ Search for a matching client application name.

      find_client_definition (application, old_application_file, client_definition);
      IF client_definition <> NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$application_already_defined, client, status);
      IFEND;
      IF status.normal THEN

{ Search for a matching server application name.

        find_server_definition (application, old_application_file, server_definition);
        IF server_definition <> NIL THEN
          osp$set_status_abnormal (nac$status_id, nae$application_already_defined, server, status);
        IFEND;
      IFEND;

      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$verify_application_name;
?? TITLE := '[XDCL, #GATE] nap$verify_tcpip_name', EJECT ??
*copyc nah$verify_tcpip_name

  PROCEDURE [XDCL, #GATE] nap$verify_tcpip_name
    (    application: nat$application_name;
     VAR status: ost$status);

    VAR
      application_file_attached: boolean,
      local_status: ost$status,
      tcpip_attributes: ^nat$tcpip_attributes,
      tcpip_definition: ^nat$complete_tcpip_definition;

    verify_appl_mgmt_capability (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF nav$namve_active THEN
      osp$push_inhibit_job_recovery;
      osp$begin_subsystem_activity;
      nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);

{ Search for a matching tcpip application name.

      nap$find_tcpip_attributes (application, tcpip_attributes);
      IF tcpip_attributes <> NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$application_already_defined, tcpip, status);
      IFEND;
      nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
      osp$end_subsystem_activity;
      osp$pop_inhibit_job_recovery;
    ELSE

{ NAMVE is not active.

      application_file_attached := FALSE;
      IF NOT highest_cycle_open THEN
        nap$attach_application_file (status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
        application_file_attached := TRUE;
      IFEND;

{ Search for a matching tcpip application name.

      find_tcpip_definition (application, old_application_file, tcpip_definition);
      IF tcpip_definition <> NIL THEN
        osp$set_status_abnormal (nac$status_id, nae$application_already_defined, tcpip, status);
      IFEND;
      IF application_file_attached THEN
        nap$detach_application_file (local_status);
        IF (status.normal) AND (NOT local_status.normal) THEN
          status := local_status;
        ELSE
          nap$display_message (local_status);
        IFEND;
      IFEND;
    IFEND;

  PROCEND nap$verify_tcpip_name;
?? TITLE := '[XDCL] nlp$tcpip_decrement_appl_access', EJECT ??
*copyc nlh$tcpip_decrement_appl_access

  PROCEDURE [XDCL] nlp$tcpip_decrement_appl_access
    (    application: nat$application_name;
         global_socket_id: nlt$udp_global_socket_id;
         connection_id: nat$connection_id;
     VAR status: ost$status);

    VAR
      connection_id_in_list: boolean,
      global_socket_id_in_list: boolean,
      previous_tcp_socket_list: ^^nat$tcp_socket,
      previous_udp_socket_list: ^^nat$udp_socket,
      tcp_socket_list: ^nat$tcp_socket,
      tcpip_attributes: ^nat$tcpip_attributes,
      udp_socket_list: ^nat$udp_socket;

    status.normal := TRUE;
    nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
    nap$find_tcpip_attributes (application, tcpip_attributes);
    IF tcpip_attributes <> NIL THEN
      nlp$get_exclusive_access (tcpip_attributes^.access_control);
      IF tcpip_attributes^.protocol = nac$stream_socket THEN
        connection_id_in_list := FALSE;
        previous_tcp_socket_list := ^tcpip_attributes^.tcp_socket_list;
        tcp_socket_list := tcpip_attributes^.tcp_socket_list;

      /search_tcp/
        WHILE tcp_socket_list <> NIL DO
          IF tcp_socket_list^.connection_id = connection_id THEN
            previous_tcp_socket_list^ := tcp_socket_list^.next_entry;
            FREE tcp_socket_list IN nav$network_paged_heap^;
            connection_id_in_list := TRUE;
            EXIT /search_tcp/; {----->
          IFEND;
          previous_tcp_socket_list := ^tcp_socket_list^.next_entry;
          tcp_socket_list := tcp_socket_list^.next_entry;
        WHILEND /search_tcp/;
        IF connection_id_in_list THEN
          tcpip_attributes^.active_socket_count := tcpip_attributes^.active_socket_count - 1;
        ELSE { socket not on list

{ Ignore socket may have been terminated via application management.

        IFEND;
      ELSEIF tcpip_attributes^.protocol = nac$datagram_socket THEN
        global_socket_id_in_list := FALSE;
        previous_udp_socket_list := ^tcpip_attributes^.udp_socket_list;
        udp_socket_list := tcpip_attributes^.udp_socket_list;

      /search_udp/
        WHILE udp_socket_list <> NIL DO
          IF udp_socket_list^.global_socket_id = global_socket_id THEN
            previous_udp_socket_list^ := udp_socket_list^.next_entry;
            FREE udp_socket_list IN nav$network_paged_heap^;
            global_socket_id_in_list := TRUE;
            EXIT /search_udp/; {----->
          IFEND;
          previous_udp_socket_list := ^udp_socket_list^.next_entry;
          udp_socket_list := udp_socket_list^.next_entry;
        WHILEND /search_udp/;
        IF global_socket_id_in_list THEN
          tcpip_attributes^.active_socket_count := tcpip_attributes^.active_socket_count - 1;
        ELSE { socket not on list

{ Ignore socket may have been terminated via application management.

        IFEND;
      IFEND;
      nlp$release_exclusive_access (tcpip_attributes^.access_control);
    ELSE {unknown_application.
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
    IFEND;
    nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
  PROCEND nlp$tcpip_decrement_appl_access;
?? TITLE := '[XDCL] nlp$tcpip_increment_appl_access', EJECT ??
*copyc nlh$tcpip_increment_appl_access

  PROCEDURE [XDCL] nlp$tcpip_increment_appl_access
    (    application: nat$application_name;
         socket_assigned: boolean;
         global_socket_id: nlt$udp_global_socket_id;
         connection_id: nat$connection_id;
     VAR status: ost$status);

    VAR
      tcpip_attributes: ^nat$tcpip_attributes;

    status.normal := TRUE;
    nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
    nap$find_tcpip_attributes (application, tcpip_attributes);
    IF tcpip_attributes <> NIL THEN
      nlp$get_exclusive_access (tcpip_attributes^.access_control);
      IF tcpip_attributes^.tcpip_status = nac$application_active THEN
        tcpip_attributes^.socket_attempt_count := tcpip_attributes^.socket_attempt_count + 1;
        IF tcpip_attributes^.active_socket_count < tcpip_attributes^.maximum_sockets THEN
          IF tcpip_attributes^.protocol = nac$stream_socket THEN
            nap$add_tcp_socket_list (socket_assigned, connection_id, tcpip_attributes);
          ELSE {    datagram socket
            nap$add_udp_socket_list (global_socket_id, tcpip_attributes);
          IFEND;
          tcpip_attributes^.active_socket_count := tcpip_attributes^.active_socket_count + 1;
        ELSE {maximum sockets exceeded
          osp$set_status_abnormal (nac$status_id, nae$maximum_sockets_exceeded, application, status);
          tcpip_attributes^.socket_reject_count := tcpip_attributes^.socket_reject_count + 1;
        IFEND;
      ELSE {    reject application inactive.
        osp$set_status_abnormal (nac$status_id, nae$application_inactive, application, status);
      IFEND;
      nlp$release_exclusive_access (tcpip_attributes^.access_control);
    ELSE {unknown_application.
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
    IFEND;
    nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);
  PROCEND nlp$tcpip_increment_appl_access;
?? TITLE := '[XDCL] nlp$tcpip_set_socket_assigned', EJECT ??
*copyc nlh$tcpip_set_socket_assigned

  PROCEDURE [XDCL] nlp$tcpip_set_socket_assigned
    (    application: nat$application_name;
         connection_id: nat$connection_id;
     VAR status: ost$status);

    VAR
      tcp_socket_list: ^nat$tcp_socket,
      tcpip_attributes: ^nat$tcpip_attributes;

    status.normal := TRUE;
    nlp$get_nonexclusive_access (nav$tcpip_attributes_list.access_control);
    nap$find_tcpip_attributes (application, tcpip_attributes);
    IF tcpip_attributes <> NIL THEN
      nlp$get_exclusive_access (tcpip_attributes^.access_control);
      IF tcpip_attributes^.protocol = nac$stream_socket THEN
        IF tcpip_attributes^.tcpip_status = nac$application_active THEN
          tcp_socket_list := tcpip_attributes^.tcp_socket_list;
          WHILE (tcp_socket_list <> NIL) AND (tcp_socket_list^.connection_id <> connection_id) DO
            tcp_socket_list := tcp_socket_list^.next_entry;
          WHILEND;
          IF tcp_socket_list <> NIL THEN
            tcp_socket_list^.socket_assigned := TRUE;
          ELSE
            osp$set_status_abnormal (nac$status_id, nae$unknown_socket, application, status);
          IFEND;
        ELSE {  reject application inactive.
          osp$set_status_abnormal (nac$status_id, nae$application_inactive, application, status);
        IFEND;
      ELSE {  application not TCP
        osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
      IFEND;
      nlp$release_exclusive_access (tcpip_attributes^.access_control);
    ELSE {unknown_application.
      osp$set_status_abnormal (nac$status_id, nae$unknown_application, application, status);
    IFEND;
    nlp$release_nonexclusive_access (nav$tcpip_attributes_list.access_control);

  PROCEND nlp$tcpip_set_socket_assigned;

*copyc nap$add_tcp_socket_list
*copyc nap$add_udp_socket_list
*copyc nap$find_client_attributes
*copyc nap$find_server_attributes
*copyc nap$find_tcpip_attributes
*copyc nap$validate_user
*copyc nlp$get_exclusive_access
*copyc nlp$get_nonexclusive_access
*copyc nlp$release_exclusive_access
*copyc nlp$release_nonexclusive_access
MODEND nam$application_management;
