?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE : Network Management : File Cycle Manager' ??
MODULE nam$file_cycle_manager;
?? RIGHT := 110 ??

{ PURPOSE:
{   This deck contains procedures which access and manipulate
{   information related to cycles.
{ DESIGN:
{   DOWN_TIME - Initialized to zero when the network file is created.
{                   Set (if a valid_start_down_time) to the difference
{                   between current time and start_down_time plus the
{                   old down_time value when a valid connection_identifier
{                   is stored in the file i.e. when valid_start_down_time
{                   is set to FALSE down_time should be set.
{   START_TIME - Initialized to the current time when the network file
{                   is created or a new connected connection_identifier
{                   is stored in the file.  Start_time is reset to the
{                   current time or start_down_time in fmp$get_connect_
{                   time_interval.  Start_time is set to current time if
{                   the connection is established.  It is set to start_
{                   down_time if the connection is disconnected.
{   START_DOWN_TIME - Set to the current time when the connection is
{                   disconnected.  Start_down_time is valid only if
{                   valid_start_down_time is TRUE.
{   VALID_START_DOWN_TIME - Set to TRUE when the connection is disconnected.
{                   Valid_start_down_time is set to FALSE when a connected
{                   connection_identifier is stored in the file.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ame$device_class_validation
*copyc ame$lfn_program_actions
*copyc nac$null_connection_id
*copyc nae$application_interfaces
*copyc nae$internal_interactive_appl
*copyc nae$namve_conditions
*copyc osd$integer_limits
*copyc ost$status
*copyc rme$request_command_exceptions
?? POP ??
*copyc bap$set_evaluated_file_abnormal
*copyc fmp$evaluate_path
*copyc fmp$get_cycle_description
*copyc fmp$unlock_path_table
*copyc nap$get_connection_state
*copyc nlp$connect_unsimulated_broken
*copyc nlp$connection_simulated_broken
*copyc nlp$nominal_conn_registration
*copyc nlp$nominal_disconnect_record
*copyc nlp$open_file
*copyc nlp$switch_offer_set
*copyc osp$append_status_parameter
*copyc osp$fetch_locked_variable
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition

*copyc amv$device_class_names
*copyc jmv$connection_acquired
*copyc osv$task_shared_heap

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$clear_switch_offer', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$clear_switch_offer
    (    file: fst$file_reference;
         switch_complete: boolean;
     VAR status: ost$status);

    VAR
      connection_state: nat$connection_state,
      current_time: integer,
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF (cycle_description^.attached_file) AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$switch_offered THEN
        IF switch_complete THEN
          global_file_information_p^.file_state := nac$switch_completed;
        ELSE
          global_file_information_p^.file_state := nac$normal;
          cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
                global_file_information_p^.backup_connection_id;
          IF NOT global_file_information_p^.disconnect_indication THEN
            nap$get_connection_state (cycle_description^.global_file_information^.device_dependent_info.
                  network_connection_id, connection_state, status);
            IF status.normal THEN
              IF connection_state <> nac$terminated THEN
                current_time := #FREE_RUNNING_CLOCK (0);
                global_file_information_p^.connect.down_time :=
                      global_file_information_p^.connect.down_time +
                      (current_time - global_file_information_p^.connect.start_down_time);
                global_file_information_p^.connect.valid_start_down_time := FALSE;
              ELSE { IF connection_state = nac$terminated THEN
                global_file_information_p^.disconnect_indication := TRUE;
              IFEND;
            IFEND;
          IFEND;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$nominal_conn_switch_offer THEN
        IF switch_complete THEN
          global_file_information_p^.file_state := nac$terminated_nominal_connect;
        ELSE
          global_file_information_p^.file_state := nac$simulated_connection_broken;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$system_recovery_switched THEN
        global_file_information_p^.file_state := nac$system_recovery;
      ELSEIF global_file_information_p^.file_state = nac$system_recovery_switchd_nom THEN
        global_file_information_p^.file_state := nac$system_recovery;
      ELSEIF global_file_information_p^.file_state = nac$normal THEN
        osp$set_status_condition (nae$no_switch_offer_pending, status);
      ELSEIF global_file_information_p^.file_state = nac$nominal_normal THEN
        osp$set_status_condition (nae$nominal_connection, status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        osp$set_status_condition (nae$system_interrupt, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$clear_switch_offer;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$convert_status', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$convert_status
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      internal_status: ost$status;

    IF (NOT status.normal) AND (status.condition = nae$connection_terminated) THEN
      fmp$get_cycle_description (file, cycle_description, internal_status);
      IF NOT internal_status.normal THEN
        RETURN; {----->
      IFEND;

      IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
        global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
              network_global_file_information;
        IF global_file_information_p^.file_state = nac$nominal_normal THEN
          osp$set_status_condition (nae$interactive_cond_interrupt, status);
        ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
          osp$set_status_condition (nae$interactive_cond_interrupt, status);
        ELSEIF global_file_information_p^.file_state = nac$nominal_conn_switch_offer THEN
          osp$set_status_condition (nae$interactive_cond_interrupt, status);
        ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
          osp$set_status_condition (nae$interactive_cond_interrupt, status);
        ELSEIF (global_file_information_p^.file_state = nac$system_recovery) OR
              (global_file_information_p^.file_state = nac$system_recovery_switched) OR
              (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
          osp$set_status_condition (nae$system_interrupt, status);
        IFEND;
      IFEND;
      fmp$unlock_path_table;
    IFEND;

  PROCEND fmp$convert_status;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$create_network_file', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$create_network_file
    (    file: fst$file_reference;
         connection_id: nat$connection_id;
         connection_state: nat$connection_state;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      evaluated_file_reference: fst$evaluated_file_reference,
      network_global_file_information: ^nat$global_file_information;

    cycle_description := NIL;

    fmp$evaluate_path (file, $bat$process_pt_work_list [bac$resolve_path, bac$resolve_to_catalog,
          bac$return_cycle_description, bac$record_path, bac$create_cycle_description],
          evaluated_file_reference, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

  /path_table_locked/
    BEGIN
      IF ((cycle_description^.static_setfa_entries <> NIL) OR
            (cycle_description^.dynamic_setfa_entries <> NIL)) THEN
        bap$set_evaluated_file_abnormal (evaluated_file_reference, ame$file_known, 'FMP$CREATE_NETWORK_FILE',
              '', status);
        EXIT /path_table_locked/; {----->
      IFEND;

      ; {
      ; { initiallizes the cycle_description
      ; {


      verify_device_assignment (evaluated_file_reference, rmc$network_device, cycle_description, status);
      IF NOT status.normal THEN
        EXIT /path_table_locked/; {----->
      IFEND;

      IF NOT cycle_description^.attached_file THEN
        cycle_description^.attached_file := TRUE;
        cycle_description^.system_file_label.file_previously_opened := FALSE;
        cycle_description^.system_file_label.static_label := NIL;

{ If you change the following two lines, check the procedure
{ iip$xt_create_network_file.  This procedure sets the application_info_source to
{ amc$local_file_information and application_info to osc$timesharing_terminal_file.
{ These values allow the system to detect the difference between a normal network file
{ and a network file created to support xterm.

        cycle_description^.system_file_label.descriptive_label.application_info_source :=
              amc$undefined_attribute;
        cycle_description^.system_file_label.descriptive_label.global_access_mode :=
              $pft$usage_selections [pfc$read, pfc$shorten, pfc$append, pfc$modify];
        cycle_description^.system_file_label.descriptive_label.global_access_mode_source :=
              amc$access_method_default;
        cycle_description^.system_file_label.descriptive_label.global_file_name_source :=
              amc$undefined_attribute;
        cycle_description^.system_file_label.descriptive_label.internal_cycle_name_source :=
              amc$undefined_attribute;
        cycle_description^.system_file_label.descriptive_label.global_share_mode := $pft$share_selections [];
        cycle_description^.system_file_label.descriptive_label.global_share_mode_source :=
              amc$access_method_default;
        cycle_description^.system_file_label.descriptive_label.permanent_file := FALSE;
        cycle_description^.device_class := rmc$network_device;
        cycle_description^.global_file_information^.device_dependent_info.device_class := rmc$network_device;

        ALLOCATE network_global_file_information IN osv$task_shared_heap^;
        network_global_file_information^.file_state := nac$normal;
        network_global_file_information^.connect.start_time := #FREE_RUNNING_CLOCK (0);
        network_global_file_information^.connect.down_time := 0;
        IF connection_state <> nac$terminated THEN
          network_global_file_information^.connect.valid_start_down_time := FALSE;
          network_global_file_information^.disconnect_indication := FALSE;
        ELSE { IF connection_state = nac$terminated THEN
          network_global_file_information^.connect.start_down_time :=
                network_global_file_information^.connect.start_time;
          network_global_file_information^.connect.valid_start_down_time := TRUE;
          network_global_file_information^.disconnect_indication := TRUE;
        IFEND;
        cycle_description^.global_file_information^.device_dependent_info.network_global_file_information :=
              network_global_file_information;
        cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
              connection_id;
      ELSE
        osp$set_status_condition (ame$file_known, status);
      IFEND;

    END /path_table_locked/;

    fmp$unlock_path_table;

  PROCEND fmp$create_network_file;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$create_rhfam_file', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$create_rhfam_file
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      evaluated_file_reference: fst$evaluated_file_reference;

    cycle_description := NIL;

    fmp$evaluate_path (file, $bat$process_pt_work_list [bac$resolve_path, bac$resolve_to_catalog,
          bac$return_cycle_description, bac$record_path, bac$create_cycle_description],
          evaluated_file_reference, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

  /path_table_locked/
    BEGIN
      verify_device_assignment (evaluated_file_reference, rmc$rhfam_device, cycle_description, status);
      IF NOT status.normal THEN
        EXIT /path_table_locked/; {----->
      IFEND;

      IF NOT cycle_description^.attached_file THEN
        cycle_description^.attached_file := TRUE;
        cycle_description^.system_file_label.file_previously_opened := FALSE;
        cycle_description^.system_file_label.static_label := NIL;
        cycle_description^.system_file_label.descriptive_label.application_info_source :=
              amc$undefined_attribute;
        cycle_description^.system_file_label.descriptive_label.global_access_mode :=
              $pft$usage_selections [pfc$read, pfc$shorten, pfc$append, pfc$modify];
        cycle_description^.system_file_label.descriptive_label.global_access_mode_source :=
              amc$access_method_default;
        cycle_description^.system_file_label.descriptive_label.global_file_name_source :=
              amc$undefined_attribute;
        cycle_description^.system_file_label.descriptive_label.internal_cycle_name_source :=
              amc$undefined_attribute;
        cycle_description^.system_file_label.descriptive_label.global_share_mode := $pft$share_selections [];
        cycle_description^.system_file_label.descriptive_label.global_share_mode_source :=
              amc$access_method_default;
        cycle_description^.system_file_label.descriptive_label.permanent_file := FALSE;
        cycle_description^.device_class := rmc$rhfam_device;
      ELSE
        osp$set_status_condition (ame$file_known, status);
      IFEND;

    END /path_table_locked/;

    fmp$unlock_path_table;

  PROCEND fmp$create_rhfam_file;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$delete_network_file', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$delete_network_file
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file THEN
      IF cycle_description^.device_class = rmc$network_device THEN
        osp$set_status_abnormal (amc$access_method_id, 20 {device_class_mismatch} , 'rmp$delete_network_file',
              status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$delete_network_file;

?? TITLE := '[XDCL, #GATE] fmp$get_connect_time_interval', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$get_connect_time_interval
    (    file: fst$file_reference;
     VAR connect_time: ost$non_negative_integers;
     VAR status: ost$status);

    VAR
      connect_time_interval: integer,
      current_time: integer,
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF NOT global_file_information_p^.connect.valid_start_down_time THEN
        current_time := #FREE_RUNNING_CLOCK (0);

{ connect_time := current_time - (start_time + down_time)

        connect_time := current_time - (global_file_information_p^.connect.start_time +
              global_file_information_p^.connect.down_time);
        global_file_information_p^.connect.start_time := current_time;
        global_file_information_p^.connect.down_time := 0;
      ELSE { IF cd^.gfi^.ddi.ngfi^.connect.valid_start_down_time THEN

{ connect_time_interval := start_down_time - (start_time + down_time);

        connect_time_interval := global_file_information_p^.connect.start_down_time -
              (global_file_information_p^.connect.start_time + global_file_information_p^.connect.down_time);

{ Check for a zero connect time.  It is possible to get a negative connect time.
{ When the mainframe goes through a recovery deadstart, periodically the
{ microsecond clock is initialized to a value smaller than it was before the
{ mainframe was taken down.  The psr NV0R942 will address this problem.

        IF connect_time_interval > 0 THEN
          connect_time := connect_time_interval;
        ELSE
          connect_time := 0;
        IFEND;
        global_file_information_p^.connect.start_time := global_file_information_p^.connect.start_down_time;
        global_file_information_p^.connect.down_time := 0;
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$get_connect_time_interval;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$get_connection_identifier', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$get_connection_identifier
    (    file: fst$file_reference;
     VAR connection_id: nat$connection_id;
     VAR switch_offer_pending: boolean;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;

      IF (global_file_information_p^.file_state = nac$normal) OR
            (global_file_information_p^.file_state = nac$nominal_normal) THEN
        connection_id := cycle_description^.global_file_information^.device_dependent_info.
              network_connection_id;
        switch_offer_pending := FALSE;
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        connection_id := global_file_information_p^.backup_connection_id;
        switch_offer_pending := FALSE;
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) THEN
        connection_id := global_file_information_p^.backup_connection_id;
        switch_offer_pending := TRUE;
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF (global_file_information_p^.file_state = nac$system_recovery) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$system_interrupt, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$get_connection_identifier;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$open_network_file', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$open_network_file
    (    file: fst$file_reference;
         file_identifier: amt$file_identifier;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF (global_file_information_p^.file_state = nac$normal) OR
            (global_file_information_p^.file_state = nac$nominal_normal) OR NOT jmv$connection_acquired THEN
        nlp$open_file (cycle_description^.global_file_information^.device_dependent_info.
              network_connection_id, file_identifier, status);
      ELSEIF (global_file_information_p^.file_state = nac$simulated_connection_broken) THEN
        nlp$open_file (global_file_information_p^.backup_connection_id, file_identifier, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$switch_offer_pending, status);
      ELSE
        osp$set_status_condition (nae$connection_not_established, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$open_network_file;

?? TITLE := '[XDCL, #GATE] fmp$process_disconnect', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$process_disconnect
    (    file: fst$file_reference;
         connection_id: nat$connection_id);

    VAR
      cycle_description: ^fmt$cycle_description,
      status: ost$status;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file THEN
      IF cycle_description^.device_class = rmc$network_device THEN

{ Start the down time only if the connection_ids match.  Otherwise
{ a connection that has just received a new connection id could be
{ invalidated.

        IF connection_id = cycle_description^.global_file_information^.device_dependent_info.
              network_connection_id THEN
          IF NOT cycle_description^.global_file_information^.device_dependent_info.
                network_global_file_information^.connect.valid_start_down_time THEN
            cycle_description^.global_file_information^.device_dependent_info.
                  network_global_file_information^.connect.start_down_time := #FREE_RUNNING_CLOCK (0);
            cycle_description^.global_file_information^.device_dependent_info.
                  network_global_file_information^.connect.valid_start_down_time := TRUE;
          IFEND;
          cycle_description^.global_file_information^.device_dependent_info.network_global_file_information^.
                disconnect_indication := TRUE;
        IFEND;
      IFEND;
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$process_disconnect;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$record_nominal_disconnect', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$record_nominal_disconnect
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$nominal_normal THEN
        nlp$nominal_disconnect_record (cycle_description^.global_file_information^.device_dependent_info.
              network_connection_id, status);
        IF status.normal THEN
          global_file_information_p^.file_state := nac$terminated_nominal_connect;
          cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
                nac$null_connection_id;
          IF NOT global_file_information_p^.connect.valid_start_down_time THEN
            global_file_information_p^.connect.start_down_time := #FREE_RUNNING_CLOCK (0);
            global_file_information_p^.connect.valid_start_down_time := TRUE;
          IFEND;
        IFEND;
      ELSEIF (global_file_information_p^.file_state = nac$system_recovery) THEN
        global_file_information_p^.file_state := nac$terminated_nominal_connect;
      ELSEIF global_file_information_p^.file_state = nac$normal THEN
        osp$set_status_condition (nae$not_nominal_connection, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$switch_offer_pending, status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$record_nominal_disconnect;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$disconnect_for_clone', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$disconnect_for_clone
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      global_file_information_p^.file_state := nac$terminated_nominal_connect;
      cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
            nac$null_connection_id;
      global_file_information_p^.connect.start_time := #FREE_RUNNING_CLOCK (0);
      global_file_information_p^.connect.down_time := 0;
      global_file_information_p^.connect.valid_start_down_time := TRUE;
      global_file_information_p^.connect.start_down_time := global_file_information_p^.connect.start_time;
      global_file_information_p^.disconnect_indication := FALSE;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$disconnect_for_clone;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$register_nominal_connection', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$register_nominal_connection
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$normal THEN
        nlp$nominal_conn_registration (cycle_description^.global_file_information^.device_dependent_info.
              network_connection_id, status);
        IF status.normal THEN
          global_file_information_p^.file_state := nac$nominal_normal;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        global_file_information_p^.file_state := nac$terminated_nominal_connect;
        cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
              nac$null_connection_id;
      ELSEIF global_file_information_p^.file_state = nac$nominal_normal THEN
        osp$set_status_condition (nae$nominal_connection, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$switch_offer_pending, status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$register_nominal_connection;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$remove_connection_id', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$remove_connection_id
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      global_file_information_p: ^nat$global_file_information,
      cycle_description: ^fmt$cycle_description;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$normal THEN
        cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
              nac$null_connection_id;
        global_file_information_p^.file_state := nac$connection_terminated;
        IF NOT global_file_information_p^.connect.valid_start_down_time THEN
          global_file_information_p^.connect.start_down_time := #FREE_RUNNING_CLOCK (0);
          global_file_information_p^.connect.valid_start_down_time := TRUE;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$nominal_normal THEN
        osp$set_status_condition (nae$nominal_connection, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$switch_offer_pending, status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        osp$set_status_condition (nae$system_interrupt, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$remove_connection_id;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$set_switch_offer', EJECT ??

{ NOTES:
{   If the current state is nac$system_recovery the file_state will be changed to
{   nac$system_recovery_switched or nac$system_recovery_switchd_nom depending on the
{   value of the parameter timesharing_connection_switch.  In addition, the error
{   nae$system_interrupt will be returned if the file state is nac$system_recovery.

  PROCEDURE [XDCL, #GATE] fmp$set_switch_offer
    (    file: fst$file_reference;
         timesharing_connection_switch: boolean;
     VAR application_name: nat$application_name;
     VAR connection_id: nat$connection_id;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF (NOT timesharing_connection_switch) AND (global_file_information_p^.file_state = nac$normal) THEN
        osp$fetch_locked_variable (cycle_description^.global_file_information^.open_count, open_count);
        IF open_count > 0 THEN
          osp$set_status_condition (ame$file_not_closed, status);
        ELSE
          nlp$switch_offer_set (cycle_description^.global_file_information^.device_dependent_info.
                network_connection_id, application_name, status);
          IF status.normal THEN
            global_file_information_p^.file_state := nac$switch_offered;
            connection_id := cycle_description^.global_file_information^.device_dependent_info.
                  network_connection_id;
            global_file_information_p^.backup_connection_id := connection_id;
            cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
                  nac$null_connection_id;
            IF NOT global_file_information_p^.connect.valid_start_down_time THEN
              global_file_information_p^.connect.start_down_time := #FREE_RUNNING_CLOCK (0);
              global_file_information_p^.connect.valid_start_down_time := TRUE;
            IFEND;
          IFEND;
        IFEND;
      ELSEIF (timesharing_connection_switch) AND (global_file_information_p^.file_state =
            nac$simulated_connection_broken) THEN
        nlp$switch_offer_set (global_file_information_p^.backup_connection_id, application_name, status);
        IF status.normal THEN
          connection_id := global_file_information_p^.backup_connection_id;
          global_file_information_p^.file_state := nac$nominal_conn_switch_offer;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$normal THEN
        osp$set_status_condition (nae$not_nominal_connection, status);
      ELSEIF global_file_information_p^.file_state = nac$nominal_normal THEN
        osp$set_status_condition (nae$nominal_connection, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$switch_offer_pending, status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        osp$set_status_condition (nae$system_interrupt, status);
        IF NOT timesharing_connection_switch THEN
          osp$fetch_locked_variable (cycle_description^.global_file_information^.open_count, open_count);
          IF open_count > 0 THEN
            osp$set_status_condition (ame$file_not_closed, status);
          ELSE
            global_file_information_p^.file_state := nac$system_recovery_switched;
          IFEND;
        ELSE
          global_file_information_p^.file_state := nac$system_recovery_switchd_nom;
        IFEND;
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$set_switch_offer;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$simulate_connection_broken', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$simulate_connection_broken
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$nominal_normal THEN
        nlp$connection_simulated_broken (cycle_description^.global_file_information^.device_dependent_info.
              network_connection_id, status);
        IF status.normal THEN
          global_file_information_p^.file_state := nac$simulated_connection_broken;
          global_file_information_p^.backup_connection_id :=
                cycle_description^.global_file_information^.device_dependent_info.network_connection_id;
          cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
                nac$null_connection_id;
          IF NOT global_file_information_p^.connect.valid_start_down_time THEN
            global_file_information_p^.connect.start_down_time := #FREE_RUNNING_CLOCK (0);
            global_file_information_p^.connect.valid_start_down_time := TRUE;
          IFEND;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$normal THEN
        osp$set_status_condition (nae$not_nominal_connection, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_condition (nae$switch_offer_pending, status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_condition (nae$switch_offer_accepted, status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        osp$set_status_condition (nae$system_interrupt, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$simulate_connection_broken;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$store_connection_id', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$store_connection_id
    (    file: fst$file_reference;
         connection_id: nat$connection_id;
     VAR status: ost$status);

    VAR
      connection_state: nat$connection_state,
      current_time: integer,
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
              connection_id;
        global_file_information_p^.file_state := nac$normal;
        nap$get_connection_state (connection_id, connection_state, status);
        IF status.normal THEN
          IF connection_state <> nac$terminated THEN
            current_time := #FREE_RUNNING_CLOCK (0);
            global_file_information_p^.connect.down_time := global_file_information_p^.connect.down_time +
                  (current_time - global_file_information_p^.connect.start_down_time);
            global_file_information_p^.connect.valid_start_down_time := FALSE;
            global_file_information_p^.disconnect_indication := FALSE;
          ELSE { IF connection_state = nac$terminated THEN
            global_file_information_p^.disconnect_indication := TRUE;
          IFEND;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$normal THEN
        osp$set_status_condition (nae$connection_active, status);
      ELSEIF global_file_information_p^.file_state = nac$nominal_normal THEN
        osp$set_status_condition (nae$nominal_connection, status);
      ELSEIF (global_file_information_p^.file_state = nac$switch_offered) OR
            (global_file_information_p^.file_state = nac$nominal_conn_switch_offer) OR
            (global_file_information_p^.file_state = nac$system_recovery_switched) OR
            (global_file_information_p^.file_state = nac$system_recovery_switchd_nom) THEN
        osp$set_status_abnormal (nac$status_id, nae$switch_offer_pending, 'nac$switch_offered', status);
      ELSEIF global_file_information_p^.file_state = nac$switch_completed THEN
        osp$set_status_abnormal (nac$status_id, nae$switch_offer_accepted, 'nac$switch_completed', status);
      ELSEIF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        osp$set_status_condition (nae$simulated_connect_broken, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        osp$set_status_abnormal (nac$status_id, nae$system_interrupt, 'nac$system_recovery', status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$store_connection_id;

?? TITLE := 'PROCEDURE [XDCL, #GATE] fmp$unsimulate_connection_broke', EJECT ??

  PROCEDURE [XDCL, #GATE] fmp$unsimulate_connection_broke
    (    file: fst$file_reference;
     VAR status: ost$status);

    VAR
      connection_state: nat$connection_state,
      current_time: integer,
      cycle_description: ^fmt$cycle_description,
      global_file_information_p: ^nat$global_file_information,
      open_count: integer;

    fmp$get_cycle_description (file, cycle_description, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF cycle_description^.attached_file AND (cycle_description^.device_class = rmc$network_device) THEN
      global_file_information_p := cycle_description^.global_file_information^.device_dependent_info.
            network_global_file_information;
      IF global_file_information_p^.file_state = nac$simulated_connection_broken THEN
        nlp$connect_unsimulated_broken (global_file_information_p^.backup_connection_id, status);
        global_file_information_p^.file_state := nac$normal;
        cycle_description^.global_file_information^.device_dependent_info.network_connection_id :=
              global_file_information_p^.backup_connection_id;
        IF NOT global_file_information_p^.disconnect_indication THEN
          nap$get_connection_state (cycle_description^.global_file_information^.device_dependent_info.
                network_connection_id, connection_state, status);
          IF status.normal THEN
            IF connection_state <> nac$terminated THEN
              current_time := #FREE_RUNNING_CLOCK (0);
              global_file_information_p^.connect.down_time := global_file_information_p^.connect.down_time +
                    (current_time - global_file_information_p^.connect.start_down_time);
              global_file_information_p^.connect.valid_start_down_time := FALSE;
            ELSE { IF connection_state = nac$terminated THEN
              global_file_information_p^.disconnect_indication := TRUE;
            IFEND;
          IFEND;
        IFEND;
      ELSEIF global_file_information_p^.file_state = nac$terminated_nominal_connect THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$connection_terminated THEN
        osp$set_status_condition (nae$connection_terminated, status);
      ELSEIF global_file_information_p^.file_state = nac$system_recovery THEN
        osp$set_status_condition (nae$system_interrupt, status);
      ELSE
        osp$set_status_condition (nae$not_simulated_conn_broken, status);
      IFEND;
    ELSE
      osp$set_status_condition (ame$improper_device_class, status);
    IFEND;

    fmp$unlock_path_table;

  PROCEND fmp$unsimulate_connection_broke;

?? TITLE := 'PROCEDURE [INLINE] verify_device_assignment', EJECT ??

  PROCEDURE [INLINE] verify_device_assignment
    (    evaluated_file_reference: fst$evaluated_file_reference;
         required_device_class: rmt$device_class;
         cycle_description: ^fmt$cycle_description;
     VAR status: ost$status);

    status.normal := TRUE;
    IF cycle_description^.attached_file THEN
      IF cycle_description^.device_class <> required_device_class THEN
        bap$set_evaluated_file_abnormal (evaluated_file_reference, rme$device_assignment_conflict,
              'NAM$FILE_CYCLE_MANAGER', amv$device_class_names [cycle_description^.device_class].
              name (1, amv$device_class_names [cycle_description^.device_class].size), status);
        osp$append_status_parameter (osc$status_parameter_delimiter,
              amv$device_class_names [required_device_class].name
              (1, amv$device_class_names [required_device_class].size), status);
      ELSE
        bap$set_evaluated_file_abnormal (evaluated_file_reference, rme$redundant_device_assignment,
              'NAM$FILE_CYCLE_MANAGER', amv$device_class_names [cycle_description^.device_class].
              name (1, amv$device_class_names [cycle_description^.device_class].size), status);
      IFEND;
    IFEND;

  PROCEND verify_device_assignment;
?? OLDTITLE ??
MODEND nam$file_cycle_manager;

