?? TITLE := 'NOS/VE File Server : Client Requests' ??
MODULE pfm$r2_df_client_requests;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module processes the client side of permanent file requests
{   originating from the client and destined for the server.
{
{ DESIGN:
{   The general sequence is:
{   - Call dfp$begin_remote_procedure_call to obtain a queue entry, a pointer
{     to the parameter buffer, and a pointer to the data buffer.
{  - OR -
{   - Call dfp$begin_ch_remote_proc_call to set up a condition handler for
{     remote procedure call processing, and to obtain a queue entry, a pointer
{     to the parameter buffer, and a pointer to the data buffer.
{
{   - Call a procedure to package the parameters into the parameter and data
{     buffers of the queue entry.
{   - Call dfp$send_remote_procedure_call to queue the request.  This call will
{     wait for the server to return the request.  A pointer to the parameter
{     receive buffer and a pointer to the data receive buffer are returned.
{   - Call a procedure to parse the output parameters returned by the server in
{     the parameter receive buffer and in the data receive buffer.
{   - If needed: notify the local mainframe's file manager or device manager.
{     (i.e. on attach, create, and attach_or_create call
{     create_client_file_tables.)
{   - Call dfp$end_remote_procedure_call to release the queue entry.
{  - OR -
{   - Call dfp$end_ch_remote_proc_call to release the queue entry and
{     disestablish the condition handler.
{
{  NOTE:
{  The preferred method is to use the procedures which establish/disestablish
{  condition handlers.

?? NEWTITLE := '  Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc i#current_sequence_position
*copyc oss$job_paged_literal
*copyc dfc$partially_rebuilt_fde_eoi
*copyc pfc$test_jr_constants
*copyc dfd$driver_queue_types
*copyc dfd$file_server_info
*copyc dfd$request_package
*copyc pud$selection_criteria
*copyc ame$ring_validation_errors
*copyc dfe$error_condition_codes
*copyc fse$open_validation_errors
*copyc pfe$error_condition_codes
*copyc pfe$external_archive_conditions
*copyc pfe$internal_error_conditions
*copyc rme$request_command_exceptions
*copyc dft$server_file_output
*copyc fmt$mass_storage_request_info
*copyc fmt$removable_media_req_info
*copyc fst$file_changes
*copyc fst$goi_object_information
*copyc fst$goi_validation_criteria
*copyc gft$system_file_identifier
*copyc pft$auditable_cycles
*copyc pft$auditable_permits
*copyc pft$change_list
*copyc pft$complete_path
*copyc pft$df_append_rem_media_vsn
*copyc pft$df_attach_in
*copyc pft$df_attach_or_create_in
*copyc pft$df_attach_or_create_out
*copyc pft$df_attach_out
*copyc pft$df_change_cy_dam
*copyc pft$df_change_cy_dt
*copyc pft$df_change_file_in
*copyc pft$df_change_file_out
*copyc pft$df_change_in
*copyc pft$df_change_out
*copyc pft$df_change_residence_in
*copyc pft$df_clear_cy_att_in
*copyc pft$df_define
*copyc pft$df_define_catalog
*copyc pft$df_define_data
*copyc pft$df_delete_all_arch_entries
*copyc pft$df_delete_archive_entry
*copyc pft$df_delete_permit
*copyc pft$df_get_family_set
*copyc pft$df_get_info_in
*copyc pft$df_get_info_out
*copyc pft$df_get_mcat_info
*copyc pft$df_get_obj_info_in
*copyc pft$df_get_obj_info_out
*copyc pft$df_mark_release_candidate
*copyc pft$df_permit_in
*copyc pft$df_purge_catalog_in
*copyc pft$df_purge_in
*copyc pft$df_purge_out
*copyc pft$df_put_archive_entry
*copyc pft$df_put_archive_info
*copyc pft$df_put_cycle_info
*copyc pft$df_put_item_info_in
*copyc pft$df_put_item_info_out
*copyc pft$df_release_data
*copyc pft$df_replace_archive_entry
*copyc pft$df_replace_rem_media_fmd
*copyc pft$df_resolve
*copyc pft$df_return
*copyc pft$df_save_file_label_in
*copyc pft$df_save_label_out
*copyc pft$df_save_released_label_in
*copyc pft$df_validate_password
*copyc pft$exception_selection_info
*copyc pft$internal_name
*copyc pft$p_amd
*copyc pft$p_archive_array_entry
*copyc pft$p_fmd
*copyc pft$p_info
*copyc pft$permit_level
*copyc pft$purge_cycle_options
*copyc pft$release_data_info
*copyc pft$relink_server_file
*copyc pft$save_label_audit_info
*copyc pft$served_family_locator
*copyc pft$unique_volume_list
*copyc rmt$volume_list
*copyc sft$counter
?? POP ??
*copyc clp$convert_file_ref_to_string
*copyc dfp$complement_gfn
*copyc dfp$extract_client_job_id
*copyc dfp$fetch_served_family_entry
*copyc dfp$fetch_served_family_info
*copyc dfp$receive_server_rpc_segment
*copyc dfp$send_remote_procedure_call
*copyc dfp$set_invalid_family_index
*copyc dfp$uncomplement_gfn
*copyc dmp$create_client_sft
*copyc dmp$create_tape_file_sfid
*copyc dmp$detach_server_file
*copyc dmp$fixup_client_file_length
*copyc dmp$replace_client_sft
*copyc dmp$set_file_state
*copyc fmp$attach_file
*copyc fmp$change_recorded_cycle_num
*copyc fmp$change_recorded_file_name
*copyc fmp$get_path_table_cycle_info
*copyc fmp$locate_cd_via_path_handle
*copyc fmp$lock_path_table
*copyc fmp$process_pt_request
*copyc fmp$unlock_path_table
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$clear_job_signature_lock
*copyc osp$file_access_condition
*copyc osp$set_job_signature_lock
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$set_status_from_condition
*copyc pfp$check_device_availability
*copyc pfp$convert_pft$path_to_fs_path
*copyc pfp$convert_pft$path_to_fs_str
*copyc pfp$convert_pft$path_to_string
*copyc pfp$get_rem_media_req_info
*copyc pfp$get_rem_media_volume_list
*copyc pfp$log_error
*copyc pfp$pick_modes_for_open
*copyc pfp$process_unexpected_status
*copyc pfp$report_unexpected_status
*copyc pmp$get_executing_task_gtid
*copyc pmp$get_job_names
*copyc pmp$get_pseudo_mainframe_id
*copyc syp$decrement_server_file_count
*copyc syp$increment_server_file_count
*copyc dfv$file_server_debug_enabled
*copyc dfv$file_server_info_enabled
*copyc dfv$job_recovery_enabled
*copyc dfv$use_server_io
*copyc gfv$null_sfid
*copyc pfv$space_character
*copyc pfv$write_usage
*copyc syv$test_jr_job

?? TITLE := '  Global Declarations Declared by this module', EJECT ??

  CONST
    allowed_when_server_deactivated = TRUE,
    inhibit_path_table_lock = TRUE;

?? FMT (FORMAT := OFF) ??
  VAR
    null_server_file_output: [oss$job_paged_literal, READ] dft$server_file_output := [
          {bytes_per_allocation}      dmc$min_bytes_per_allocation,

{ Put eoi and file_limit high enough so that fetch_page_status won't object to a reference beyond file limit.

          {eoi_byte_address}          dfc$partially_rebuilt_fde_eoi,
          {file_limit}                dfc$partially_rebuilt_fde_eoi,
          {preset_value}              0,
          {remote_sfid}               [0, gfc$tr_null_residence, gfc$null_file_hash],
          {requested_transfer_size}   dmc$default_req_transfer_size,
          {shared_queue}              mmc$null_shared_queue,
          {total_allocated_length}    dfc$partially_rebuilt_fde_eoi];
?? FMT (FORMAT := ON) ??

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_app_rem_me_vsn', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_app_rem_me_vsn
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         volume_descriptor: rmt$volume_descriptor;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_app_rem_me_vsn; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_app_rem_me_vsn_buffer (path, cycle_selector, volume_descriptor, p_send_to_server_params,
            parameter_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_app_rem_me_vsn, parameter_size,
              {send_data_size} 0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_app_rem_me_vsn;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_attach', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_attach
    (    served_family_locator: pft$served_family_locator;
         lfn: amt$local_file_name;
         path: pft$path;
         attach_input: pft$df_attach_in;
     VAR cycle_number: fst$cycle_number;
     VAR device_class: rmt$device_class;
     VAR cycle_damage_symptoms: fst$cycle_damage_symptoms;
     VAR global_file_name: dmt$global_file_name;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_attach; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      authority: pft$authority,
      client_job_id: dft$client_job_id,
      evaluated_file_reference: fst$evaluated_file_reference,
      local_status: ost$status,
      p_file_label: ^fmt$file_label,
      p_fmd: pft$p_fmd,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_removable_media_req_info: ^fmt$removable_media_req_info,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      p_volume_list: ^rmt$volume_list,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size,
      server_file_output: pft$server_file_output,
      volume_count: 0 .. amc$max_vol_number;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      dfp$extract_client_job_id (queue_entry_location, client_job_id);
      build_attach_send_buffer (attach_input, path, p_send_parameters, p_send_data, send_parameters_size,
            send_data_size);
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_attach, send_parameters_size,
            send_data_size, p_receive_parameters, p_receive_data, status);

      IF status.normal THEN
        parse_attach_receive_buffers (p_receive_parameters, p_receive_data, authority, cycle_number,
              device_class, cycle_damage_symptoms, global_file_name, server_file_output, p_file_label, p_fmd,
              status);

        IF status.normal THEN
          IF (device_class = rmc$magnetic_tape_device) AND (p_fmd <> NIL) THEN
            PUSH p_removable_media_req_info;
            pfp$get_rem_media_req_info (p_fmd, p_removable_media_req_info, volume_count, status);

            IF status.normal THEN
              IF server_file_output.usage_selections * pfv$write_usage <> $pft$usage_selections [] THEN
                p_removable_media_req_info^.write_ring := rmc$write_ring;
              ELSE
                p_removable_media_req_info^.write_ring := rmc$no_write_ring;
              IFEND;

              PUSH p_volume_list: [1 .. volume_count];
              pfp$get_rem_media_volume_list (p_fmd, p_volume_list, status);
            IFEND;
          ELSE
            p_removable_media_req_info := NIL;
            p_volume_list := NIL;
          IFEND;

          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
          evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
          evaluated_file_reference.cycle_reference.cycle_number := server_file_output.cycle_number;
          create_client_file_tables (served_family_locator, client_job_id, lfn, evaluated_file_reference,
                attach_input.validation_ring, device_class, authority, server_file_output,
                {implicit_attach} FALSE, p_file_label, p_removable_media_req_info, p_volume_list, status);

          IF NOT status.normal THEN
            return_server_file (server_file_output.attached_pf_table_index, {file_modified} FALSE,
                  {eoi_byte_address} 0, server_file_output.dm_parameters.remote_sfid, device_class,
                  queue_entry_location, p_send_parameters, p_receive_parameters, local_status);
            pfp$process_unexpected_status (local_status);
          IFEND;
        ELSEIF status.condition = pfe$cycle_attached_on_client THEN
          check_local_attach (path, cycle_number, lfn, attach_input.validation_ring,
                attach_input.usage_selector, attach_input.share_selector, {called_by_attach} TRUE,
                {create_file} FALSE, status);
        IFEND;
      ELSE
        device_class := rmc$mass_storage_device;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    ELSE
      device_class := rmc$mass_storage_device;
    IFEND;
  PROCEND pfp$r2_df_client_attach;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_attach_or_cref', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_attach_or_cref
    (    served_family_locator: pft$served_family_locator;
         validation_ring: ost$valid_ring;
         system_privilege: boolean;
         exception_selection_info: pft$exception_selection_info;
         p_attachment_options: {input} ^fst$attachment_options;
         p_file_label: {input} ^fmt$file_label;
         p_path_table_cycle_info: {input} ^fmt$path_table_cycle_info;
         catalog_cycle_attributes: pft$catalog_cycle_attributes;
     VAR evaluated_file_reference: {i/o} fst$evaluated_file_reference;
     VAR action_attempted: pft$action_attempted;
     VAR action_taken: pft$attach_or_create_action;
     VAR authority: pft$authority;
     VAR allowed_access: fst$file_access_options;
     VAR selected_access: fst$file_access_options;
     VAR required_sharing: fst$file_access_options;
     VAR selected_sharing: fst$file_access_options;
     VAR device_class: rmt$device_class;
     VAR global_file_name: dmt$global_file_name;
     VAR label_used: boolean;
     VAR bytes_allocated: amt$file_byte_address;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_attach_or_cref; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      client_job_id: dft$client_job_id,
      complemented_new_gfn: dmt$global_file_name,
      complemented_old_gfn: dmt$global_file_name,
      local_evaluated_file_reference: fst$evaluated_file_reference,
      local_p_file_label: ^fmt$file_label,
      local_p_path_table_cycle_info: ^fmt$path_table_cycle_info,
      local_reference_created: boolean,
      local_status: ost$status,
      new_client_sfid: gft$system_file_identifier,
      new_global_file_name: dmt$global_file_name,
      new_remote_sfid: gft$system_file_identifier,
      p_cycle_description: ^fmt$cycle_description,
      p_fmd: pft$p_fmd,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_removable_media_req_info: ^fmt$removable_media_req_info,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      p_server_file_output: ^pft$server_file_output,
      p_volume_list: ^rmt$volume_list,
      path_table_cycle_info: fmt$path_table_cycle_info,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size,
      server_file_output: pft$server_file_output,
      volume_count: 0 .. amc$max_vol_number;

    local_reference_created := FALSE;
    local_p_path_table_cycle_info := p_path_table_cycle_info;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      dfp$extract_client_job_id (queue_entry_location, client_job_id);

      IF (evaluated_file_reference.cycle_reference.specification = fsc$cycle_omitted) OR
            (evaluated_file_reference.cycle_reference.specification = fsc$high_cycle) OR
            (evaluated_file_reference.cycle_reference.specification = fsc$low_cycle) THEN
        local_evaluated_file_reference := evaluated_file_reference;
        local_reference_created := TRUE;
        fmp$get_path_table_cycle_info (inhibit_path_table_lock, local_evaluated_file_reference,
              path_table_cycle_info, status);
        IF status.normal AND path_table_cycle_info.path_registered THEN
          local_p_path_table_cycle_info := ^path_table_cycle_info;
        IFEND;
      IFEND;

      IF status.normal THEN
        REPEAT
          build_attach_or_cref_send_bufs (validation_ring, system_privilege, exception_selection_info,
                p_attachment_options, p_file_label, local_p_path_table_cycle_info, catalog_cycle_attributes,
                evaluated_file_reference, p_send_parameters, p_send_data, send_parameters_size,
                send_data_size, status);

          IF status.normal THEN
            dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_attach_or_cref,
                  send_parameters_size, send_data_size, p_receive_parameters, p_receive_data, status);
          IFEND;

          IF status.normal THEN
            parse_attach_or_cref_receive (p_receive_parameters, p_receive_data, evaluated_file_reference,
                  action_attempted, action_taken, authority, allowed_access, selected_access,
                  required_sharing, selected_sharing, device_class, global_file_name, new_global_file_name,
                  new_remote_sfid, label_used, bytes_allocated, local_p_file_label, p_fmd, server_file_output,
                  status);

            IF status.normal THEN
              CASE action_taken OF
              = pfc$cycle_newly_attached, pfc$cycle_created =
                {
                { The file was attached or created on the server.
                {
                IF (device_class = rmc$magnetic_tape_device) AND (p_fmd <> NIL) THEN
                  PUSH p_removable_media_req_info;
                  pfp$get_rem_media_req_info (p_fmd, p_removable_media_req_info, volume_count, status);
                  IF status.normal THEN
                    IF (server_file_output.usage_selections * pfv$write_usage) <> $pft$usage_selections
                          [] THEN
                      p_removable_media_req_info^.write_ring := rmc$write_ring;
                    ELSE
                      p_removable_media_req_info^.write_ring := rmc$no_write_ring;
                    IFEND;
                    PUSH p_volume_list: [1 .. volume_count];
                    pfp$get_rem_media_volume_list (p_fmd, p_volume_list, status);
                  IFEND;
                ELSE
                  p_removable_media_req_info := NIL;
                  p_volume_list := NIL;
                IFEND;
                create_client_file_tables (served_family_locator, client_job_id,
                      {local_file_name} osc$null_name, evaluated_file_reference, validation_ring,
                      device_class, authority, server_file_output, {implicit_attach} TRUE, local_p_file_label,
                      p_removable_media_req_info, p_volume_list, status);

                IF NOT status.normal THEN
                  return_server_file (server_file_output.attached_pf_table_index, {file_modified} FALSE,
                        {eoi_byte_address} 0, server_file_output.dm_parameters.remote_sfid, device_class,
                        queue_entry_location, p_send_parameters, p_receive_parameters, local_status);
                  pfp$process_unexpected_status (local_status);
                IFEND;

              ELSE { The cycle is already attached in the job.
                IF new_remote_sfid <> gfv$null_sfid THEN
                  dfp$complement_gfn (global_file_name, complemented_old_gfn);
                  dfp$complement_gfn (new_global_file_name, complemented_new_gfn);
                  dmp$replace_client_sft (complemented_old_gfn, complemented_new_gfn, new_remote_sfid,
                        new_client_sfid, local_status);
                  IF local_status.normal THEN
                    IF local_reference_created THEN
                      fmp$locate_cd_via_path_handle (local_evaluated_file_reference.path_handle_info.
                            path_handle, {lock_path_table} FALSE, p_cycle_description, local_status);
                    ELSE
                      fmp$locate_cd_via_path_handle (evaluated_file_reference.path_handle_info.path_handle,
                            {lock_path_table} FALSE, p_cycle_description, local_status);
                    IFEND;
                    IF local_status.normal THEN
                      p_cycle_description^.system_file_id := new_client_sfid;
                      global_file_name := new_global_file_name;
                    IFEND;
                  IFEND;
                IFEND;
                IF local_reference_created THEN
                  {
                  { Use the previously established file reference so that the
                  { path handle name has been established.
                  {
                  evaluated_file_reference := local_evaluated_file_reference;
                IFEND;
              CASEND;
            ELSEIF status.condition = pfe$recheck_client_mainframe THEN
              {
              { The local mainframe needs to recheck the path table with the
              { resolved cycle number from the catalog.
              {
              fmp$get_path_table_cycle_info (inhibit_path_table_lock, evaluated_file_reference,
                    path_table_cycle_info, local_status);
              IF local_status.normal THEN
                IF path_table_cycle_info.path_registered THEN
                  local_p_path_table_cycle_info := ^path_table_cycle_info;
                IFEND;
                RESET p_send_parameters;
                RESET p_send_data;
              ELSE
                status := local_status;
              IFEND;
            IFEND;
          ELSE
            device_class := rmc$mass_storage_device;
          IFEND;
        UNTIL (status.normal) OR (status.condition <> pfe$recheck_client_mainframe);
      ELSE
        device_class := rmc$mass_storage_device;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    ELSE
      device_class := rmc$mass_storage_device;
    IFEND;
  PROCEND pfp$r2_df_client_attach_or_cref;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_change', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_change
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         system_privilege: boolean;
         change_list: pft$change_list;
     VAR cycle_number: fst$cycle_number;
     VAR device_class: rmt$device_class;
     VAR change_index: ost$non_negative_integers;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_change; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size;

    change_index := 0;

    fmp$lock_path_table (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    validate_path_table_change (path, change_list, status);

    IF status.normal THEN
      dfp$begin_ch_remote_proc_call (served_family_locator.server_location,
            NOT allowed_when_server_deactivated, queue_entry_location, p_send_parameters, p_send_data,
            status);

      IF status.normal THEN
        build_change_send_buffers (path, cycle_selector, password, system_privilege, change_list,
              p_send_parameters, p_send_data, send_parameters_size, send_data_size, status);

        IF status.normal THEN
          dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_change, send_parameters_size,
                send_data_size, p_receive_parameters, p_receive_data, status);
        IFEND;

        IF status.normal THEN
          parse_change_receive_buffer (p_receive_parameters, cycle_number, device_class, change_index,
                status);
        IFEND;

        dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
        pfp$process_unexpected_status (local_status);
      IFEND;

      IF status.normal THEN
        change_path_table (path, cycle_number, change_list, change_index, status);
      IFEND;
    IFEND;

    fmp$unlock_path_table;
  PROCEND pfp$r2_df_client_change;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_change_cy_dam', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_change_cy_dam
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         new_damage_symptoms: fst$cycle_damage_symptoms;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_change_cy_dam; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);

    IF status.normal THEN
      build_change_cy_dam_send_buffer (path, cycle_selector, password, new_damage_symptoms,
            p_send_to_server_params, parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_change_cy_dam, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_change_cy_dam;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_change_cy_dt', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_change_cy_dt
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         new_access_date_time: pft$date_time;
         new_creation_date_time: pft$date_time;
         new_modification_date_time: pft$date_time;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_change_cy_dt; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);

    IF status.normal THEN
      build_change_cy_dt_send_buffer (path, cycle_selector, password, new_access_date_time,
            new_creation_date_time, new_modification_date_time, p_send_to_server_params, parameter_size,
            status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_change_cy_dt, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_change_cy_dt;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_change_file', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_change_file
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         system_privilege: boolean;
         file_changes: ^fst$file_changes;
     VAR cycle_number: fst$cycle_number;
     VAR device_class: rmt$device_class;
     VAR change_index: ost$non_negative_integers;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_change_file; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size;

    change_index := 0;

    fmp$lock_path_table (status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    validate_path_table_change_file (path, file_changes, status);

    IF status.normal THEN
      dfp$begin_ch_remote_proc_call (served_family_locator.server_location,
            NOT allowed_when_server_deactivated, queue_entry_location, p_send_parameters, p_send_data,
            status);

      IF status.normal THEN
        build_change_file_send_buffers (path, cycle_selector, password, system_privilege, file_changes,
              p_send_parameters, p_send_data, send_parameters_size, send_data_size, status);

        IF status.normal THEN
          dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_change_file,
                send_parameters_size, send_data_size, p_receive_parameters, p_receive_data, status);
        IFEND;

        IF status.normal THEN
          parse_change_file_receive (p_receive_parameters, cycle_number, device_class, change_index, status);
        IFEND;

        dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
        pfp$process_unexpected_status (local_status);
      IFEND;

      IF status.normal THEN
        change_file_path_table (path, cycle_number, file_changes, change_index, status);
      IFEND;
    IFEND;

    fmp$unlock_path_table;
  PROCEND pfp$r2_df_client_change_file;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_change_res_rel', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_change_res_rel
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_change_res_rel; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_change_res_rel_send_buf (path, cycle_selector, p_send_parameters, send_parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_change_res_rel,
              send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_change_res_rel;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_clear_cy_att', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_clear_cy_att
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_clear_cy_att; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      send_parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_clear_cy_att_send_buffer (path, cycle_selector, password, p_send_parameters, send_parameter_size,
            status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_clear_cy_att,
              send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_clear_cy_att;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_define', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_define
    (    served_family_locator: pft$served_family_locator;
         lfn: amt$local_file_name;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         log: pft$log;
         catalog_cycle_attributes: pft$catalog_cycle_attributes;
         system_privilege: boolean;
         validation_ring: ost$valid_ring;
         device_class: rmt$device_class;
         p_mass_storage_request_info: {input} ^fmt$mass_storage_request_info;
         p_removable_media_req_info: {input} ^fmt$removable_media_req_info;
         p_volume_list: {input} ^rmt$volume_list;
     VAR cycle_number: fst$cycle_number;
     VAR authority: pft$authority;
     VAR bytes_allocated: amt$file_byte_address;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_define; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      client_job_id: dft$client_job_id,
      evaluated_file_reference: fst$evaluated_file_reference,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      purge_cycle_options: pft$purge_cycle_options,
      purge_cycle_selector: pft$cycle_selector,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameters_size: dft$send_parameter_size,
      server_file_output: pft$server_file_output;

    fmp$lock_path_table (status);

    IF status.normal THEN
      dfp$begin_ch_remote_proc_call (served_family_locator.server_location,
            NOT allowed_when_server_deactivated, queue_entry_location, p_send_parameters, p_send_data,
            status);
      IF status.normal THEN
        dfp$extract_client_job_id (queue_entry_location, client_job_id);
        build_define_send_buffer (path, cycle_selector, password, log, catalog_cycle_attributes,
              system_privilege, validation_ring, device_class, p_mass_storage_request_info,
              p_removable_media_req_info, p_volume_list, p_send_parameters, send_parameters_size, status);

        IF status.normal THEN
          dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_define, send_parameters_size,
                {send data size} 0, p_receive_parameters, p_receive_data, status);
        IFEND;
        IF status.normal THEN
          parse_define_receive_params (p_receive_parameters, authority, bytes_allocated, server_file_output);

          cycle_number := server_file_output.cycle_number;
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
          evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
          evaluated_file_reference.cycle_reference.cycle_number := server_file_output.cycle_number;

          create_client_file_tables (served_family_locator, client_job_id, lfn, evaluated_file_reference,
                validation_ring, device_class, authority, server_file_output, {implicit_attach} FALSE,
                {p_file_label} NIL, p_removable_media_req_info, p_volume_list, status);
          IF NOT status.normal THEN
            {
            { Purge the file first, to assure we are purging the correct cycle.
            {
            purge_cycle_selector.cycle_option := pfc$specific_cycle;
            purge_cycle_selector.cycle_number := server_file_output.cycle_number;
            purge_cycle_options.preserve_cycle_entry := FALSE;
            purge_server_file (path, purge_cycle_selector, password, purge_cycle_options, system_privilege,
                  validation_ring, queue_entry_location, p_send_parameters, p_send_data, p_receive_parameters,
                  local_status);
            pfp$process_unexpected_status (local_status);

            return_server_file (server_file_output.attached_pf_table_index, {file_modified} FALSE,
                  {eoi_byte_address} 0, server_file_output.dm_parameters.remote_sfid, device_class,
                  queue_entry_location, p_send_parameters, p_receive_parameters, local_status);
            pfp$process_unexpected_status (local_status);
          IFEND;
        IFEND;

        dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
        pfp$process_unexpected_status (local_status);
      IFEND;

      fmp$unlock_path_table;
    IFEND;

  PROCEND pfp$r2_df_client_define;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_define_catalog', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_define_catalog
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         charge_id: pft$charge_id;
         system_privilege: boolean;
         catalog_type_selected: boolean;
         selected_catalog_type: pft$catalog_types;
         p_mass_storage_request_info: ^fmt$mass_storage_request_info;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_define_catalog; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      parameter_size: dft$send_parameter_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_define_cat_send_buffer (path, charge_id, system_privilege, catalog_type_selected,
            selected_catalog_type, p_mass_storage_request_info, p_send_to_server_params, parameter_size,
            status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_create_catalog, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_define_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_define_data', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_define_data
    (    served_family_locator: pft$served_family_locator;
         lfn: amt$local_file_name;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         update_cycle_statistics: boolean;
         password_selector: pft$password_selector;
         validation_ring: ost$valid_ring;
         p_mass_storage_request_info: ^fmt$mass_storage_request_info;
         p_volume_list: ^array [1 .. * ] of rmt$recorded_vsn;
         purge_cycle_options: pft$purge_cycle_options;
         replace_cycle_data: boolean;
         restore_selections: put$restore_data_selections;
     VAR mandated_modification_time: {Input, Output} pft$mandated_modification_time;
     VAR data_residence: pft$data_residence;
     VAR authority: pft$authority;
     VAR bytes_allocated: amt$file_byte_address;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_define_data; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      client_job_id: dft$client_job_id,
      evaluated_file_reference: fst$evaluated_file_reference,
      local_status: ost$status,
      p_file_label: fmt$p_file_label,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      purge_cycle_selector: pft$cycle_selector,
      queue_entry_location: dft$rpc_queue_entry_location,
      server_file_output: pft$server_file_output;

    fmp$lock_path_table (status);
    IF status.normal THEN

      dfp$begin_ch_remote_proc_call (served_family_locator.server_location,
            NOT allowed_when_server_deactivated, queue_entry_location, p_send_to_server_params, p_send_data,
            status);
      IF status.normal THEN
        dfp$extract_client_job_id (queue_entry_location, client_job_id);
        build_define_data_send_buffer (lfn, path, cycle_selector, update_cycle_statistics, password_selector,
              validation_ring, p_mass_storage_request_info, p_volume_list, purge_cycle_options,
              replace_cycle_data, restore_selections, mandated_modification_time, p_send_to_server_params,
              parameter_size, status);

        IF status.normal THEN
          dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_define_data, parameter_size,
                0, p_receive_from_server_params, p_receive_data, status);
        IFEND;
        IF status.normal THEN
          parse_define_data_params (p_receive_from_server_params, p_receive_data, mandated_modification_time,
                data_residence, authority, bytes_allocated, server_file_output, p_file_label);

          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
          evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
          evaluated_file_reference.cycle_reference.cycle_number := server_file_output.cycle_number;
          create_client_file_tables (served_family_locator, client_job_id, lfn, evaluated_file_reference,
                validation_ring, {device_class} rmc$mass_storage_device, authority, server_file_output,
                {implicit_attach} FALSE, p_file_label, {p_removable_media_req_info} NIL, {p_volume_list} NIL,
                status);
          IF NOT status.normal THEN
            {
            { We have to write a routine to reset the FMD to NIL and call it here.
            {

            return_server_file (server_file_output.attached_pf_table_index, {file_modified} FALSE,
                  {eoi_byte_address} 0, server_file_output.dm_parameters.remote_sfid,
                  {device_class} rmc$mass_storage_device, queue_entry_location, p_send_to_server_params,
                  p_receive_from_server_params, local_status);
            pfp$process_unexpected_status (local_status);
          IFEND;
        IFEND;

        dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
        pfp$process_unexpected_status (local_status);
      IFEND;

      fmp$unlock_path_table;
    IFEND;

  PROCEND pfp$r2_df_client_define_data;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_del_all_arc_en', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_del_all_arc_en
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_del_all_arc_en; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_del_all_arch_ent_buffer (path, cycle_selector, p_send_to_server_params, parameter_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_del_all_arc_en, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_del_all_arc_en;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_del_arch_entry', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_del_arch_entry
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_del_arch_entry; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_send_data: dft$p_send_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_delete_arch_entry_buffer (path, cycle_selector, archive_identification, p_send_to_server_params,
            parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_del_arch_entry, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_del_arch_entry;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_delete_permit', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_delete_permit
    (    path: pft$path;
         object_type: pft$object_types,
         system_privilege: boolean;
         group: pft$group;
         served_family_locator: pft$served_family_locator;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_delete_permit; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      parameter_size: dft$send_parameter_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);

    IF status.normal THEN
      build_delete_permit_send_buffer (path, object_type, system_privilege, group, p_send_to_server_params,
            parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_delete_permit, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_delete_permit;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_get_family_set', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_get_family_set
    (    family_name: pft$name;
         served_family_locator: pft$served_family_locator;
     VAR set_name: stt$set_name;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_get_family_set; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_get_fam_set_send_buffer (family_name, p_send_parameters, send_parameter_size);
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_get_family_set,
            send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);

      IF status.normal THEN
        parse_get_fam_set_receive_param (p_receive_parameters, set_name);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_get_family_set;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_get_famit_info', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_get_famit_info
    (    family_name: pft$name;
         catalog_info_selections: pft$catalog_info_selections;
         served_family_locator: pft$served_family_locator;
     VAR set_name: pft$name;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_get_famit_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_get_mcat_info_send_buffer (family_name, catalog_info_selections, p_send_parameters,
            send_parameter_size);
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_get_famit_info,
            send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);

      IF status.normal THEN
        parse_get_famit_info_params (p_receive_parameters, p_receive_data, set_name, p_info, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_get_famit_info;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_get_info', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_get_info
    (    info_selection: pft$get_info_selection;
         path: pft$path;
         system_privilege: boolean;
         group: pft$group;
         catalog_info_selections: pft$catalog_info_selections;
         file_info_selections: pft$file_info_selections;
         served_family_locator: pft$served_family_locator;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_get_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      parameter_size: dft$send_parameter_size,
      local_status: ost$status,
      p_get_info_output: ^pft$df_get_info_out,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      p_server_info: ^pft$info,
      p_user_info: ^pft$info,
      queue_entry_location: dft$rpc_queue_entry_location;

    status.normal := TRUE;
    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    build_get_info_send_buffer (info_selection, path, system_privilege, group, catalog_info_selections,
          file_info_selections, p_send_to_server_params, parameter_size, status);

    IF status.normal THEN
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_get_info, parameter_size, 0,
            p_receive_from_server_params, p_receive_data, status);
      IF status.normal THEN
        IF p_receive_data = NIL THEN
          NEXT p_get_info_output IN p_receive_from_server_params;
          dfp$receive_server_rpc_segment (queue_entry_location, {server_segment_offset} 0,
                p_get_info_output^.info_size, p_info, status);
          IF (NOT status.normal) AND (status.condition = dfe$info_full) THEN
            osp$set_status_condition (pfe$info_full, status);
          IFEND;
        ELSE
          NEXT p_user_info: [[REP #SIZE (p_receive_data^) OF cell]] IN p_info;
          IF p_user_info = NIL THEN
            osp$set_status_condition (pfe$info_full, status);
          ELSE
            NEXT p_server_info: [[REP #SIZE (p_receive_data^) OF cell]] IN p_receive_data;
            p_user_info^ := p_server_info^;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

    dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
    pfp$process_unexpected_status (local_status);
  PROCEND pfp$r2_df_client_get_info;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_get_mcat_info', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_get_mcat_info
    (    family_name: pft$name;
         catalog_info_selections: pft$catalog_info_selections;
         served_family_locator: pft$served_family_locator;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_get_mcat_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      info_size: ost$segment_length,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_get_mcat_info_send_buffer (family_name, catalog_info_selections, p_send_parameters,
            send_parameter_size);
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_get_mcat_info,
            send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);

      IF status.normal THEN
        parse_get_mcat_receive_param (p_receive_parameters, info_size);
        dfp$receive_server_rpc_segment (queue_entry_location, {server_segment_offset} 0, info_size, p_info,
              status);
        IF (NOT status.normal) AND (status.condition = dfe$info_full) THEN
          osp$set_status_condition (pfe$info_full, status);
        IFEND;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_get_mcat_info;

?? TITLE := '  [XDCL] pfp$r2_df_client_get_obj_info', EJECT ??

  PROCEDURE [XDCL] pfp$r2_df_client_get_obj_info
    (    served_family_locator: pft$served_family_locator;
         evaluated_file_reference: fst$evaluated_file_reference;
         information_request: fst$goi_information_request;
         system_privilege: boolean;
         password_selector: pft$password_selector;
         subject_permit_count: ost$non_negative_integers;
         validation_ring: ost$valid_ring;
         p_validation_criteria: {i/o^} ^fst$goi_validation_criteria;
         p_object_info: {input} ^fst$goi_object_information;
     VAR object_info_offset: ost$segment_offset;
     VAR p_object_information: ^SEQ ( * );
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_get_obj_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameter_size: dft$send_parameter_size;

    object_info_offset := 0;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_get_obj_info_send_buffer (evaluated_file_reference, information_request, system_privilege,
            password_selector, subject_permit_count, validation_ring, p_validation_criteria,
            p_send_parameters, send_parameter_size, p_send_data, send_data_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_get_obj_info,
              send_parameter_size, send_data_size, p_receive_parameters, p_receive_data, status);
      IFEND;

      IF status.normal THEN
        parse_get_obj_info_receive_bufs (p_validation_criteria, p_object_info, queue_entry_location,
              p_receive_parameters, p_receive_data, object_info_offset, p_object_information, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_get_obj_info;
?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_get_vol_cl', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_get_vol_cl
    (    served_family_locator: pft$served_family_locator;
         unique_volume_list: pft$unique_volume_list;
     VAR volume_condition_list: fst$volume_condition_list;
     VAR status: ost$status);

?? TITLE := '  build_get_vol_cond_send_buffer', EJECT ??

    PROCEDURE build_get_vol_cond_send_buffer
      (    unique_volume_list: pft$unique_volume_list;
       VAR p_send_to_server_params: dft$p_send_parameters;
       VAR parameter_size: dft$send_parameter_size);

      VAR
        p_number_of_volumes: ^amt$volume_number,
        p_unique_volume_list: ^pft$unique_volume_list;

      NEXT p_number_of_volumes IN p_send_to_server_params;
      p_number_of_volumes^ := UPPERBOUND (unique_volume_list) - LOWERBOUND (unique_volume_list) + 1;

      NEXT p_unique_volume_list: [1 .. p_number_of_volumes^] IN p_send_to_server_params;
      p_unique_volume_list^ := unique_volume_list;

      parameter_size := i#current_sequence_position (p_send_to_server_params);

    PROCEND build_get_vol_cond_send_buffer;
?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to
{ clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.
{ The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_get_vol_cl; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??
?? TITLE := '  parse_get_vol_cond_receive_param', EJECT ??

    PROCEDURE get_vol_cond_receive_param
      (VAR p_receive_from_server_params: dft$p_receive_parameters;
       VAR volume_condition_list: fst$volume_condition_list);

      VAR
        p_number_of_volumes: ^amt$volume_number,
        p_volume_condition_list: ^fst$volume_condition_list;

      NEXT p_number_of_volumes IN p_receive_from_server_params;

      NEXT p_volume_condition_list: [1 .. p_number_of_volumes^] IN p_receive_from_server_params;
      volume_condition_list := p_volume_condition_list^;

    PROCEND get_vol_cond_receive_param;
?? EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_get_vol_cond_send_buffer (unique_volume_list, p_send_parameters, send_parameter_size);
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_get_vol_cond,
            send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);

      IF status.normal THEN
        get_vol_cond_receive_param (p_receive_parameters, volume_condition_list);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_get_vol_cl;
?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_mark_rel_cand', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_mark_rel_cand
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         validation_ring: ost$valid_ring;
         archive_identification: pft$archive_identification;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_mark_rel_cand; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_mark_rel_candidate_buffer (path, cycle_selector, password, validation_ring,
            archive_identification, p_send_to_server_params, parameter_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_mark_rel_cand, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_mark_rel_cand;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_permit', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_permit
    (    path: pft$path;
         object_type: pft$object_types;
         system_privilege: boolean;
         permit_level: pft$permit_level;
         group: pft$group;
         permit_selections: pft$permit_selections;
         share_requirements: pft$share_requirements;
         application_info: pft$application_info;
         served_family_locator: pft$served_family_locator;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_permit; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_permit_send_buffer (path, object_type, system_privilege, permit_level, group, permit_selections,
            share_requirements, application_info, p_send_parameters, send_parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_permit, send_parameter_size,
              {send_data_size} 0, p_receive_parameters, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_permit;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_purge', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_purge
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         purge_cycle_options: pft$purge_cycle_options;
         system_privilege: boolean;
         validation_ring: ost$valid_ring;
     VAR authority: pft$authority;
     VAR device_class: rmt$device_class;
     VAR bytes_released: amt$file_byte_address;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_purge; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      purge_server_file (path, cycle_selector, password, purge_cycle_options, system_privilege,
            validation_ring, queue_entry_location, p_send_parameters, p_send_data, p_receive_parameters,
            status);

      IF status.normal THEN
        parse_purge_receive_buffer (p_receive_parameters, authority, device_class, bytes_released, status);
      ELSE
        device_class := rmc$mass_storage_device;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    ELSE
      device_class := rmc$mass_storage_device;
    IFEND;
  PROCEND pfp$r2_df_client_purge;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_purge_catalog', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_purge_catalog
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         system_privilege: boolean;
         delete_option: pft$delete_option;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_purge_catalog; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_purge_catalog_send_buffer (path, system_privilege, delete_option, p_send_parameters, p_send_data,
            send_parameters_size, send_data_size);
      dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_delete_catalog,
            send_parameters_size, send_data_size, p_receive_parameters, p_receive_data, status);

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_purge_catalog;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_put_arch_entry', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_put_arch_entry
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
         p_archive_array_entry: pft$p_archive_array_entry;
         p_amd: pft$p_amd;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_put_arch_entry; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      data_size: dft$send_data_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_put_archive_entry_buffer (path, cycle_selector, archive_identification, p_archive_array_entry,
            p_amd, p_send_to_server_params, p_send_data, parameter_size, data_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_put_arch_entry, parameter_size,
              data_size, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_put_arch_entry;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_put_arch_info', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_put_arch_info
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         p_cycle_info_record: pft$p_info_record;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_put_arch_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      data_size: dft$send_data_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_put_archive_info_buffer (path, cycle_selector, p_cycle_info_record, p_send_to_server_params,
            p_send_data, parameter_size, data_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_put_arch_info, parameter_size,
              data_size, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_put_arch_info;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_put_cycle_info', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_put_cycle_info
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         cycle_array_entry: pft$cycle_array_entry_version_2;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_put_cycle_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      parameter_size: dft$send_parameter_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      purge_cycle_selector: pft$cycle_selector,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_put_cycle_info_buffer (path, cycle_selector, password_selector, cycle_array_entry,
            p_send_to_server_params, parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_put_cycle_info, parameter_size,
              0, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_put_cycle_info;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_put_item_info', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_put_item_info
    (    backup_file_version: pft$backup_file_version;
         p_info_record: {input} ^pft$info_record;
         served_family_locator: pft$served_family_locator;
         path: pft$path;
         permit_level: pft$permit_level;
         selection_criteria: put$selection_criteria;
         restore_archive_information: boolean;
     VAR audit_restorations: {i/o} boolean;
     VAR all_permits_restored: boolean;
     VAR p_auditable_permits: ^pft$auditable_permits;
     VAR p_auditable_cycles: ^pft$auditable_cycles;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_put_item_info; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_put_item_info_send_bufs (backup_file_version, p_info_record, path, permit_level,
            selection_criteria, restore_archive_information, audit_restorations, p_auditable_permits,
            p_auditable_cycles, p_send_parameters, send_parameters_size, p_send_data, send_data_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_put_info, send_parameters_size,
              send_data_size, p_receive_parameters, p_receive_data, status);
      IFEND;

      IF status.normal THEN
        parse_put_item_info_receipts (p_receive_parameters, p_receive_data, audit_restorations,
              all_permits_restored, p_auditable_permits, p_auditable_cycles, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_put_item_info;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_release_data', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_release_data
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         p_release_data_info: {i/o} ^pft$release_data_info;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_release_data; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_rd_info: ^pft$release_data_info,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_parameter_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_release_data_buffer (path, cycle_selector, password, p_release_data_info, p_send_parameters,
            send_parameter_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_release_data,
              send_parameter_size, {send_data_size} 0, p_receive_parameters, p_receive_data, status);
      IFEND;

      IF status.normal AND (p_release_data_info <> NIL) THEN
        NEXT p_rd_info IN p_receive_parameters;
        p_release_data_info^ := p_rd_info^;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_release_data;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_rep_arch_entry', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_rep_arch_entry
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
         p_archive_array_entry: pft$p_archive_array_entry;
         p_amd: pft$p_amd;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_rep_arch_entry; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      data_size: dft$send_data_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_rep_archive_entry_buffer (path, cycle_selector, archive_identification, p_archive_array_entry,
            p_amd, p_send_to_server_params, p_send_data, parameter_size, data_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_rep_arch_entry, parameter_size,
              data_size, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

  PROCEND pfp$r2_df_client_rep_arch_entry;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_rep_rem_me_fmd', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_rep_rem_me_fmd
    (    served_family_locator: pft$served_family_locator;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         replace_existing_rem_media_fmd: boolean;
         p_file_media_descriptor: {input} ^SEQ ( * );
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_rep_rem_me_fmd; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      data_size: dft$send_data_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      parameter_size: dft$send_parameter_size,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      build_rep_rem_me_fmd_buffer (path, cycle_selector, password_selector, replace_existing_rem_media_fmd,
            p_file_media_descriptor, p_send_to_server_params, p_send_data, parameter_size, data_size, status);
      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_rep_rem_me_fmd, parameter_size,
              data_size, p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_rep_rem_me_fmd;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_resolve', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_resolve
    (    path: pft$path;
         served_family_locator: pft$served_family_locator;
         system_privilege: boolean;
     VAR cycle_reference: {i/o} fst$cycle_reference;
     VAR path_resolution: fst$path_resolution;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_resolve; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      parameter_size: dft$send_parameter_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);

    IF status.normal THEN
      build_resolve_send_buffer (path, system_privilege, cycle_reference, p_send_to_server_params,
            parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_resolve, parameter_size, 0,
              p_receive_from_server_params, p_receive_data, status);
      IFEND;

      IF status.normal THEN
        parse_resolve_receive_params (p_receive_from_server_params, cycle_reference, path_resolution);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_resolve;

?? TITLE := '  [XDCL] pfp$r2_df_client_return', EJECT ??

  PROCEDURE [XDCL] pfp$r2_df_client_return
    (    apfid: pft$attached_permanent_file_id;
         client_sfid: gft$system_file_identifier;
         device_class: rmt$device_class;
         usage_selections: pft$usage_selections;
     VAR authority: pft$authority;
     VAR bytes_allocated_change: sft$counter;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_return; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      detach_status: ost$status,
      file_modified: boolean,
      flush_pages: boolean,
      eoi_byte_address: amt$file_byte_address,
      local_status: ost$status,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      server_location: dft$server_location,
      server_sfid: gft$system_file_identifier,
      sft_deleted: boolean,
      queue_entry_location: dft$rpc_queue_entry_location;

{ If the file has already been terminated as a result of a failed file server job recovery - detailed in the
{ procedure fmp$terminate_server_files - it has also already been detached to prevent a "dangling" FDE.
{ DO NOT DETACH IT AGAIN!  This will screw up the attach count.

    IF apfid.server_lifetime = 0 THEN
      RETURN; {----->
    IFEND;

    IF device_class = rmc$mass_storage_device THEN
      flush_pages := (usage_selections <> $pft$usage_selections []);
      pfp$check_device_availability (apfid, status);
      IF NOT status.normal THEN
        { Return on dfe$server_not_active to allow waiting at a higher ring
        IF (status.condition = dfe$server_has_terminated) OR
              (pfc$tjr_allow_return_await_rec IN syv$test_jr_job) THEN
          { Get rid of the system file table entry
          dmp$detach_server_file (client_sfid, flush_pages, {unconditional_detach=} FALSE, file_modified,
                eoi_byte_address, server_sfid, detach_status);
        IFEND;
        IF (pfc$tjr_allow_return_await_rec IN syv$test_jr_job) THEN
          status.normal := TRUE;
        IFEND;
        RETURN; {----->
      IFEND;
    IFEND;

    IF device_class = rmc$mass_storage_device THEN
      dmp$detach_server_file (client_sfid, flush_pages, {unconditional_detach=} FALSE, file_modified,
            eoi_byte_address, server_sfid, detach_status);
      IF NOT detach_status.normal THEN
        IF osp$file_access_condition (detach_status) THEN
          { Allow waiting at a higher ring. System file table entry not deleted.
          RETURN; {----->
        ELSEIF (detach_status.condition <> mme$io_write_error) THEN
          pfp$report_unexpected_status (detach_status);
        IFEND;
      IFEND;
      sft_deleted := detach_status.normal;
    IFEND;

    server_location.server_location_selector := dfc$served_family_table_index;
    server_location.served_family_table_index := apfid.served_family_table_index;

    dfp$begin_ch_remote_proc_call (server_location, allowed_when_server_deactivated, queue_entry_location,
          p_send_to_server_params, p_send_data, status);
    IF status.normal THEN
      return_server_file (apfid.server_attached_pf_table_index, file_modified, eoi_byte_address, server_sfid,
            device_class, queue_entry_location, p_send_to_server_params, p_receive_from_server_params,
            status);
      IF status.normal THEN
        parse_return_receive_params (p_receive_from_server_params, authority, bytes_allocated_change);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;

    IF device_class = rmc$mass_storage_device THEN
      IF (status.normal) AND (NOT detach_status.normal) THEN
        status := detach_status;
      ELSEIF (NOT status.normal) AND NOT osp$file_access_condition (status) AND
            (status.condition <> mme$io_write_error) THEN
        pfp$report_unexpected_status (status);
      IFEND;

      IF (NOT status.normal) AND (osp$file_access_condition (status) OR
            (status.condition = dfe$server_request_terminated)) AND sft_deleted THEN
        { A timing window occurred such that the server became
        { unavailable (inactive, or awaiting recovery) after the sft entry
        { was deleted.  Tell bam everything is OK to allow the entry
        { to be removed from the cycle description.
        { Without the system file table entry there is no use in leaving
        { the file in the cycle description. In the awaiting_recovery case
        { the file will be detached on the server during server job recovery.
        status.normal := TRUE;
      IFEND;
    IFEND;

    IF status.normal THEN
      syp$decrement_server_file_count;
    IFEND;

  PROCEND pfp$r2_df_client_return;

?? TITLE := '  [XDCL] pfp$r2_df_client_save_label', EJECT ??

  PROCEDURE [XDCL] pfp$r2_df_client_save_label
    (    apfid: pft$attached_permanent_file_id;
         system_authority: pft$system_authority;
         required_permission: pft$permit_options;
         p_file_label: {input} ^fmt$file_label;
     VAR p_save_file_label_audit_seq: {i/o} ^SEQ ( * );
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_save_label; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size,
      server_location: dft$server_location,
      queue_entry_location: dft$rpc_queue_entry_location;

    pfp$check_device_availability (apfid, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    server_location.server_location_selector := dfc$served_family_table_index;
    server_location.served_family_table_index := apfid.served_family_table_index;

    dfp$begin_ch_remote_proc_call (server_location, allowed_when_server_deactivated, queue_entry_location,
          p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_save_label_send_buffers (apfid.server_attached_pf_table_index, system_authority,
            required_permission, p_file_label, p_save_file_label_audit_seq, p_send_parameters, p_send_data,
            send_parameters_size, send_data_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_save_label,
              send_parameters_size, send_data_size, p_receive_parameters, p_receive_data, status);
      IFEND;

      IF status.normal THEN
        parse_save_label_receive_bufs (p_receive_parameters, p_receive_data, p_save_file_label_audit_seq,
              status);
      ELSE
        p_save_file_label_audit_seq := NIL;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    ELSE
      p_save_file_label_audit_seq := NIL;
    IFEND;
  PROCEND pfp$r2_df_client_save_label;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_save_rel_label', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_save_rel_label
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         p_file_label: {input^} ^fmt$file_label;
         validation_ring: ost$valid_ring;
         update_cycle_statistics: boolean;
     VAR p_save_label_audit_info: {i/o} ^pft$save_label_audit_info;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_save_rel_label; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_parameters: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_parameters, p_send_data, status);

    IF status.normal THEN
      build_save_rel_label_send_bufs (path, cycle_selector, password_selector, p_file_label, validation_ring,
            update_cycle_statistics, p_save_label_audit_info, p_send_parameters, p_send_data,
            send_parameters_size, send_data_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_save_rel_label,
              send_parameters_size, send_data_size, p_receive_parameters, p_receive_data, status);
      IFEND;

      IF status.normal THEN
        parse_save_rel_label_receipt (p_receive_parameters, p_save_label_audit_info, status);
      ELSE
        p_save_label_audit_info := NIL;
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    ELSE
      p_save_label_audit_info := NIL;
    IFEND;
  PROCEND pfp$r2_df_client_save_rel_label;

?? TITLE := '  [XDCL, #GATE] pfp$r2_df_client_validate_pw', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_client_validate_pw
    (    served_family_locator: pft$served_family_locator;
         path: pft$path;
         password: pft$password;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$r2_df_client_validate_pw; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      parameter_size: dft$send_parameter_size,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      queue_entry_location: dft$rpc_queue_entry_location;

    dfp$begin_ch_remote_proc_call (served_family_locator.server_location, NOT allowed_when_server_deactivated,
          queue_entry_location, p_send_to_server_params, p_send_data, status);

    IF status.normal THEN
      build_validate_pw_send_buffer (path, password, p_send_to_server_params, parameter_size, status);

      IF status.normal THEN
        dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_validate_pw, parameter_size, 0,
              p_receive_from_server_params, p_receive_data, status);
      IFEND;

      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$r2_df_client_validate_pw;

?? TITLE := '  [XDCL] pfp$reattach_server_file', EJECT ??

{    This procedure is executed on the client during the normal job recovery
{ process.  This is called before the server connection is active, and all that
{ is done is that a system_file_id is assigned and the system file table is
{ build, though largely unitialized.  As a result of this operation the segment
{ descriptor table extended entry should be marked to inhibit access to this
{ file.  The system file table entry will be completed as a result of the
{ pfp$relink_server_file process performed during server job recovery.
{
{    If server job recovery has been disabled or the server has been terminated
{ then access to the file will not be allowed.

  PROCEDURE [XDCL] pfp$reattach_server_file
    (    apfid: pft$attached_permanent_file_id;
         internal_cycle_name: pft$internal_name;
         client_mainframe_id: pmt$binary_mainframe_id;
         usage_selections: pft$usage_selections;
         share_selections: pft$share_selections;
     VAR new_sfid: gft$system_file_identifier;
     VAR status: ost$status);

    VAR
      p_served_family_entry: ^dft$served_family_table_entry;

    IF NOT dfv$job_recovery_enabled THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$server_file_attached,
            'The job is using server files and recovery is disabled.', status);
      RETURN; {----->
    IFEND;
    dfp$fetch_served_family_entry (apfid.served_family_table_index, p_served_family_entry, status);
    IF NOT status.normal THEN
      { invalid served family table index or nil .
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$server_file_attached,
            'The job is using server files and served family table not recovered.', status);
      RETURN; {----->
    IFEND;
    IF (p_served_family_entry^.server_state = dfc$terminated) OR
          (p_served_family_entry^.server_state = dfc$deleted) THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$server_file_attached,
            'The job is using server files and server has been terminated.', status);
      RETURN; {----->
    IFEND;
    dmp$create_client_sft (internal_cycle_name, usage_selections, share_selections, dmc$begin_job_recovery,
          null_server_file_output, apfid.served_family_table_index,
          p_served_family_entry^.server_mainframe_id, new_sfid, status);

  PROCEND pfp$reattach_server_file;

?? TITLE := '  [XDCL] pfp$relink_server_file', EJECT ??
*copy pfh$relink_server_file

  PROCEDURE [XDCL] pfp$relink_server_file
    (    old_apfid: pft$attached_permanent_file_id;
         internal_name: pft$internal_name;
         old_sfid: gft$system_file_identifier;
         device_class: rmt$device_class;
     VAR new_apfid: pft$attached_permanent_file_id;
     VAR new_sfid: gft$system_file_identifier;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT pfp$relink_server_file; {----->

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??

    VAR
      local_status: ost$status,
      p_relink_file_in: ^pft$relink_server_file_inp,
      p_relink_file_out: ^pft$relink_server_file_outp,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_to_server_params: dft$p_send_parameters,
      p_served_family_table_entry: ^dft$served_family_table_entry,
      server_location: dft$server_location,
      queue_entry_location: dft$rpc_queue_entry_location;

    status.normal := TRUE;
    { In an event of an unexpected error leave the file alone.
    new_apfid := old_apfid;
    new_sfid := old_sfid;
    dfp$fetch_served_family_entry (old_apfid.served_family_table_index, p_served_family_table_entry, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    server_location.server_location_selector := dfc$served_family_table_index;
    server_location.served_family_table_index := old_apfid.served_family_table_index;
    dfp$begin_ch_remote_proc_call (server_location, allowed_when_server_deactivated, queue_entry_location,
          p_send_to_server_params, p_send_data, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    NEXT p_relink_file_in IN p_send_to_server_params;
    p_relink_file_in^.attached_pf_table_index := old_apfid.attached_pf_table_index;

    IF device_class = rmc$mass_storage_device THEN
      dfp$uncomplement_gfn (internal_name, p_relink_file_in^.global_file_name);
    ELSEIF device_class = rmc$magnetic_tape_device THEN
      p_relink_file_in^.global_file_name := internal_name;
    IFEND;

    dfp$send_remote_procedure_call (queue_entry_location, dfc$relink_server_file, #SIZE (p_relink_file_in^),
          0, p_receive_from_server_params, p_receive_data, status);
    IF status.normal THEN
      IF device_class = rmc$mass_storage_device THEN
        NEXT p_relink_file_out IN p_receive_from_server_params;
        dmp$create_client_sft (internal_name, p_relink_file_out^.usage_selections,
              p_relink_file_out^.share_selections, dmc$complete_job_recovery,
              p_relink_file_out^.dm_parameters, old_apfid.served_family_table_index,
              p_served_family_table_entry^.server_mainframe_id, new_sfid, status);
{       Release the queue entry prior to calling dmp$fixup_client_file_length
{       since it too makes a remote request.
        dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
        pfp$process_unexpected_status (local_status);
        IF status.normal THEN
          dmp$fixup_client_file_length (new_sfid, status);
          new_apfid.family_location := pfc$server_mainframe;
          new_apfid.server_attached_pf_table_index := old_apfid.attached_pf_table_index;
          new_apfid.served_family_table_index := old_apfid.served_family_table_index;
          new_apfid.server_lifetime := p_served_family_table_entry^.server_lifetime;
        IFEND;
      ELSEIF device_class = rmc$magnetic_tape_device THEN
        new_apfid.family_location := pfc$server_mainframe;
        new_apfid.server_attached_pf_table_index := old_apfid.attached_pf_table_index;
        new_apfid.served_family_table_index := old_apfid.served_family_table_index;
        new_apfid.server_lifetime := p_served_family_table_entry^.server_lifetime;
        dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
        pfp$process_unexpected_status (local_status);
      IFEND;
    ELSE
      IF (device_class = rmc$mass_storage_device) AND ((status.condition <> dfe$server_not_active) AND
            (status.condition <> dfe$server_request_terminated)) THEN
        dmp$set_file_state (internal_name, dfc$terminated, local_status);
        { The file was not known on the server if pfe$invalid_apfid
      IFEND;
      dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
      pfp$process_unexpected_status (local_status);
    IFEND;
  PROCEND pfp$relink_server_file;

?? TITLE := '  build_attach_or_cref_send_bufs', EJECT ??

  PROCEDURE build_attach_or_cref_send_bufs
    (    validation_ring: ost$valid_ring;
         system_privilege: boolean;
         exception_selection_info: pft$exception_selection_info;
         p_attachment_options: {input} ^fst$attachment_options;
         p_file_label: {input} ^fmt$file_label;
         p_path_table_cycle_info: {input} ^fmt$path_table_cycle_info;
         catalog_cycle_attributes: pft$catalog_cycle_attributes;
         evaluated_file_reference: {i/o} fst$evaluated_file_reference;
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR p_send_data: {i^/o} dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_attachment_options: ^fst$attachment_options,
      p_local_file_label: ^fmt$file_label,
      p_local_path_table_cycle_info: ^fmt$path_table_cycle_info,
      p_attach_or_create_input: ^pft$df_attach_or_create_in;

    status.normal := TRUE;
    NEXT p_attach_or_create_input IN p_send_parameters;
    pmp$get_pseudo_mainframe_id (p_attach_or_create_input^.mainframe_id);

    p_attach_or_create_input^.validation_ring := validation_ring;
    p_attach_or_create_input^.system_privilege := system_privilege;
    p_attach_or_create_input^.exception_selection_info := exception_selection_info;
    p_attach_or_create_input^.evaluated_file_reference := evaluated_file_reference;
    p_attach_or_create_input^.catalog_cycle_attributes := catalog_cycle_attributes;

    IF p_attachment_options = NIL THEN
      p_attach_or_create_input^.number_of_attachment_options := 0;
    ELSE
      NEXT p_local_attachment_options: [1 .. UPPERBOUND (p_attachment_options^)] IN p_send_parameters;
      IF p_local_attachment_options = NIL THEN
        NEXT p_local_attachment_options: [1 .. UPPERBOUND (p_attachment_options^)] IN p_send_data;
        IF p_local_attachment_options = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_attachment_options in build_attach_or_cref_send_bufs', status);
          RETURN; {----->
        IFEND;
      IFEND;

      p_local_attachment_options^ := p_attachment_options^;
      p_attach_or_create_input^.number_of_attachment_options := UPPERBOUND (p_attachment_options^);
    IFEND;

    IF p_file_label = NIL THEN
      p_attach_or_create_input^.file_label_size := 0;
    ELSE
      NEXT p_local_file_label: [[REP #SIZE (p_file_label^) OF cell]] IN p_send_parameters;
      IF p_local_file_label = NIL THEN
        NEXT p_local_file_label: [[REP #SIZE (p_file_label^) OF cell]] IN p_send_data;
        IF p_local_file_label = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_file_label in build_attach_or_cref_send_bufs', status);
          RETURN; {----->
        IFEND;
      IFEND;

      p_local_file_label^ := p_file_label^;
      p_attach_or_create_input^.file_label_size := #SIZE (p_file_label^);
    IFEND;

    IF p_path_table_cycle_info = NIL THEN
      p_attach_or_create_input^.path_table_info_present := FALSE;
    ELSE
      NEXT p_local_path_table_cycle_info IN p_send_parameters;
      IF p_local_path_table_cycle_info = NIL THEN
        NEXT p_local_path_table_cycle_info IN p_send_data;
        IF p_local_path_table_cycle_info = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_path_table_cycle_info in build_attach_or_cref_send_bufs', status);
          RETURN; {----->
        IFEND;
      IFEND;

      p_local_path_table_cycle_info^ := p_path_table_cycle_info^;
      p_attach_or_create_input^.path_table_info_present := TRUE;
    IFEND;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_attach_or_cref_send_bufs;

?? TITLE := '  build_app_rem_me_vsn_buffer', EJECT ??

  PROCEDURE build_app_rem_me_vsn_buffer
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         volume_descriptor: rmt$volume_descriptor;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_local_file_media_descriptor: ^SEQ ( * ),
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_append_rem_me_vsn_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.volume_descriptor := volume_descriptor;
    p_send_parameters^.path_length := UPPERBOUND (path);

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_app_rem_me_vsn_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_app_rem_me_vsn_buffer;

?? TITLE := '  build_attach_send_buffer', EJECT ??

  PROCEDURE build_attach_send_buffer
    (    attach_input: pft$df_attach_in;
         path: pft$path;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR p_send_data: dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size);

    VAR
      p_attach_input: ^pft$df_attach_in,
      p_path: ^pft$path;

    NEXT p_attach_input IN p_send_parameters;
    p_attach_input^ := attach_input;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
    IFEND;
    p_path^ := path;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_attach_send_buffer;

?? TITLE := '  build_change_cy_dam_send_buffer', EJECT ??

  PROCEDURE build_change_cy_dam_send_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: ost$name;
         new_damage_symptoms: fst$cycle_damage_symptoms;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_change_cy_dam_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password := password;
    p_send_parameters^.new_damage_symptoms := new_damage_symptoms;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_change_cy_dam_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_change_cy_dam_send_buffer;

?? TITLE := '  build_change_cy_dt_send_buffer', EJECT ??

  PROCEDURE build_change_cy_dt_send_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: ost$name;
         new_access_date_time: pft$date_time;
         new_creation_date_time: pft$date_time;
         new_modification_date_time: pft$date_time;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_change_cy_dt_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password := password;
    p_send_parameters^.new_access_date_time := new_access_date_time;
    p_send_parameters^.new_creation_date_time := new_creation_date_time;
    p_send_parameters^.new_modification_date_time := new_modification_date_time;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_change_cy_dt_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_change_cy_dt_send_buffer;

?? TITLE := '  build_change_res_rel_send_buf', EJECT ??

  PROCEDURE build_change_res_rel_send_buf
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR send_parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_change_residence_input: ^pft$df_change_residence_in;

    status.normal := TRUE;
    NEXT p_change_residence_input IN p_send_parameters;
    p_change_residence_input^.cycle_selector := cycle_selector;
    p_change_residence_input^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_change_res_rel_send_buf', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    send_parameter_size := i#current_sequence_position (p_send_parameters);
  PROCEND build_change_res_rel_send_buf;

?? TITLE := '  build_change_send_buffers', EJECT ??

  PROCEDURE build_change_send_buffers
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: ost$name,
         system_privilege: boolean;
         change_list: pft$change_list;
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR p_send_data: {i^/o} dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_change_input: ^pft$df_change_in,
      p_change_list: ^pft$change_list,
      p_path: ^pft$path;

    status.normal := TRUE;
    NEXT p_change_input IN p_send_parameters;
    p_change_input^.cycle_selector := cycle_selector;
    p_change_input^.password := password;
    p_change_input^.system_privilege := system_privilege;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
    IFEND;
    p_path^ := path;
    p_change_input^.path_length := UPPERBOUND (path);

    NEXT p_change_list: [1 .. UPPERBOUND (change_list)] IN p_send_parameters;
    IF p_change_list = NIL THEN
      NEXT p_change_list: [1 .. UPPERBOUND (change_list)] IN p_send_data;
      IF p_change_list = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_change_list in build_change_send_buffers', status);
        RETURN; {----->
      IFEND;
    IFEND;
    p_change_list^ := change_list;
    p_change_input^.change_count := UPPERBOUND (change_list);

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_change_send_buffers;

?? TITLE := '  build_change_file_send_buffers', EJECT ??

  PROCEDURE build_change_file_send_buffers
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: ost$name,
         system_privilege: boolean;
         file_changes: ^fst$file_changes;
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR p_send_data: {i^/o} dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_change_file_input: ^pft$df_change_file_in,
      p_file_changes: ^fst$file_changes,
      p_path: ^pft$path;

    status.normal := TRUE;
    NEXT p_change_file_input IN p_send_parameters;
    p_change_file_input^.cycle_selector := cycle_selector;
    p_change_file_input^.password := password;
    p_change_file_input^.system_privilege := system_privilege;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
    IFEND;
    p_path^ := path;
    p_change_file_input^.path_length := UPPERBOUND (path);

    NEXT p_file_changes: [1 .. UPPERBOUND (file_changes^)] IN p_send_parameters;
    IF p_file_changes = NIL THEN
      NEXT p_file_changes: [1 .. UPPERBOUND (file_changes^)] IN p_send_data;
      IF p_file_changes = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_file_changes in build_change_file_send_buffers', status);
        RETURN; {----->
      IFEND;
    IFEND;
    p_file_changes^ := file_changes^;
    p_change_file_input^.change_file_count := UPPERBOUND (file_changes^);

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_change_file_send_buffers;

?? TITLE := '  build_clear_cy_att_send_buffer', EJECT ??

  PROCEDURE build_clear_cy_att_send_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: ost$name;
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_clear_cycle_attach_input: ^pft$df_clear_cy_att_in;

    status.normal := TRUE;
    NEXT p_clear_cycle_attach_input IN p_send_parameters;
    p_clear_cycle_attach_input^.cycle_selector := cycle_selector;
    p_clear_cycle_attach_input^.password := password;
    p_clear_cycle_attach_input^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_clear_cy_att_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_parameters);
  PROCEND build_clear_cy_att_send_buffer;

?? TITLE := '  build_define_send_buffer', EJECT ??

  PROCEDURE build_define_send_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         log: pft$log;
         catalog_cycle_attributes: pft$catalog_cycle_attributes;
         system_privilege: boolean;
         validation_ring: ost$valid_ring;
         device_class: rmt$device_class;
         p_mass_storage_request_info: {input} ^fmt$mass_storage_request_info;
         p_removable_media_req_info: {input} ^fmt$removable_media_req_info;
         p_volume_list: {input} ^rmt$volume_list;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_ms_request: ^fmt$mass_storage_request_info,
      p_path: ^pft$path,
      p_rem_media_request: ^fmt$removable_media_req_info,
      p_send_parameters: ^pft$df_define_inp,
      p_volume_list_request: ^rmt$volume_list;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password := password;
    p_send_parameters^.log := log;
    p_send_parameters^.catalog_cycle_attributes := catalog_cycle_attributes;
    p_send_parameters^.device_class := device_class;
    pmp$get_pseudo_mainframe_id (p_send_parameters^.mainframe_id);

    p_send_parameters^.system_privilege := system_privilege;
    p_send_parameters^.validation_ring := validation_ring;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_define_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    p_send_parameters^.mass_storage_request_included := p_mass_storage_request_info <> NIL;
    IF p_mass_storage_request_info <> NIL THEN
      NEXT p_ms_request IN p_send_to_server_params;
      p_ms_request^ := p_mass_storage_request_info^;
    IFEND;

    p_send_parameters^.rem_media_request_included := p_removable_media_req_info <> NIL;
    IF p_removable_media_req_info <> NIL THEN
      NEXT p_rem_media_request IN p_send_to_server_params;
      p_rem_media_request^ := p_removable_media_req_info^;
    IFEND;

    p_send_parameters^.volume_list_included := p_volume_list <> NIL;
    IF p_volume_list <> NIL THEN
      NEXT p_volume_list_request: [1 .. UPPERBOUND (p_volume_list^)] IN p_send_to_server_params;
      p_volume_list_request^ := p_volume_list^;
      p_send_parameters^.number_of_volumes := UPPERBOUND (p_volume_list^);
    ELSE
      p_send_parameters^.number_of_volumes := 0;
    IFEND;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_define_send_buffer;

?? TITLE := '  build_define_catalog_send_buffer', EJECT ??

  PROCEDURE build_define_cat_send_buffer
    (    path: pft$complete_path;
         charge_id: pft$charge_id;
         system_privilege: boolean;
         catalog_type_selected: boolean;
         selected_catalog_type: pft$catalog_types;
         p_mass_storage_request_info: ^fmt$mass_storage_request_info;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_catalog_type: ^pft$catalog_types,
      p_ms_request: ^fmt$mass_storage_request_info,
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_define_catalog_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.charge_id := charge_id;
    p_send_parameters^.system_privilege := system_privilege;
    p_send_parameters^.catalog_type_selected := catalog_type_selected;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_define_cat_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    IF catalog_type_selected THEN
      NEXT p_catalog_type IN p_send_to_server_params;
      p_catalog_type^ := selected_catalog_type;
    IFEND;

    p_send_parameters^.mass_storage_request_included := p_mass_storage_request_info <> NIL;
    IF p_mass_storage_request_info <> NIL THEN
      NEXT p_ms_request IN p_send_to_server_params;
      p_ms_request^ := p_mass_storage_request_info^;
    IFEND;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_define_cat_send_buffer;

?? TITLE := '  build_define_data_send_buffer', EJECT ??

  PROCEDURE build_define_data_send_buffer
    (    lfn: amt$local_file_name;
         path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         update_cycle_statistics: boolean;
         password_selector: pft$password_selector;
         validation_ring: ost$valid_ring;
         p_mass_storage_request_info: ^fmt$mass_storage_request_info;
         p_volume_list: ^array [1 .. * ] of rmt$recorded_vsn;
         purge_cycle_options: pft$purge_cycle_options;
         replace_cycle_data: boolean;
         restore_selections: put$restore_data_selections;
         mandated_modification_time: pft$mandated_modification_time;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_ms_request: ^fmt$mass_storage_request_info,
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_define_data_inp,
      p_local_volume_list: ^array [1 .. * ] of rmt$recorded_vsn;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.lfn := lfn;
    pmp$get_pseudo_mainframe_id (p_send_parameters^.mainframe_id);

    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.update_cycle_statistics := update_cycle_statistics;
    p_send_parameters^.password_selector := password_selector;
    p_send_parameters^.purge_cycle_options := purge_cycle_options;
    p_send_parameters^.replace_cycle_data := replace_cycle_data;
    p_send_parameters^.restore_selections := restore_selections;
    p_send_parameters^.mandated_modification_time := mandated_modification_time;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_define_data_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    p_send_parameters^.mass_storage_request_included := p_mass_storage_request_info <> NIL;
    IF p_mass_storage_request_info <> NIL THEN
      NEXT p_ms_request IN p_send_to_server_params;
      p_ms_request^ := p_mass_storage_request_info^;
    IFEND;

    p_send_parameters^.volume_list_length := 0;
    IF p_volume_list <> NIL THEN
      p_send_parameters^.volume_list_length := UPPERBOUND (p_volume_list^);
      NEXT p_local_volume_list: [1 .. UPPERBOUND (p_volume_list^)] IN p_send_to_server_params;
      p_local_volume_list^ := p_volume_list^;
    IFEND;

    p_send_parameters^.validation_ring := validation_ring;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_define_data_send_buffer;

?? TITLE := '  build_del_all_arch_ent_buffer', EJECT ??

  PROCEDURE build_del_all_arch_ent_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_delete_all_arch_ent_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_del_all_arch_ent_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_del_all_arch_ent_buffer;

?? TITLE := '  build_delete_arch_entry_buffer', EJECT ??

  PROCEDURE build_delete_arch_entry_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_delete_archive_entry_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.archive_identification := archive_identification;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_delete_arch_entry_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_delete_arch_entry_buffer;

?? TITLE := '  build_delete_permit_send_buffer', EJECT ??

  PROCEDURE build_delete_permit_send_buffer
    (    path: pft$path;
         object_type: pft$object_types;
         system_privilege: boolean;
         group: pft$group;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_delete_permit_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.object_type := object_type;
    p_send_parameters^.system_privilege := system_privilege;
    p_send_parameters^.group := group;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_delete_permit_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_delete_permit_send_buffer;

?? TITLE := '  build_get_fam_set_send_buffer', EJECT ??

  PROCEDURE build_get_fam_set_send_buffer
    (    family_name: pft$name;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size);

    VAR
      p_send_parameters: ^pft$df_get_family_set_inp;

    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.family_name := family_name;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_get_fam_set_send_buffer;

?? TITLE := '  build_get_info_send_buffer', EJECT ??

  PROCEDURE build_get_info_send_buffer
    (    info_selection: pft$get_info_selection;
         path: pft$path;
         system_privilege: boolean;
         group: pft$group;
         catalog_info_selections: pft$catalog_info_selections;
         file_info_selections: pft$file_info_selections;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_get_info_in;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.info_selection := info_selection;
    p_send_parameters^.system_privilege := system_privilege;
    p_send_parameters^.group := group;
    p_send_parameters^.catalog_info_selections := catalog_info_selections;
    p_send_parameters^.file_info_selections := file_info_selections;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_get_info_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_get_info_send_buffer;

?? TITLE := '  build_get_mcat_info_send_buffer', EJECT ??

  PROCEDURE build_get_mcat_info_send_buffer
    (    family_name: pft$name;
         catalog_info_selections: pft$catalog_info_selections;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size);

    VAR
      p_send_parameters: ^pft$df_get_mcat_info_inp;

    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.family_name := family_name;
    p_send_parameters^.catalog_info_selections := catalog_info_selections;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_get_mcat_info_send_buffer;

?? TITLE := '  build_get_obj_info_send_buffer', EJECT ??

  PROCEDURE build_get_obj_info_send_buffer
    (    evaluated_file_reference: fst$evaluated_file_reference;
         information_request: fst$goi_information_request;
         system_privilege: boolean;
         password_selector: pft$password_selector;
         subject_permit_count: ost$non_negative_integers;
         validation_ring: ost$valid_ring;
         p_validation_criteria: {input} ^fst$goi_validation_criteria;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR send_parameter_size: dft$send_parameter_size;
     VAR p_send_data: dft$p_send_data;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_get_object_info_input: ^pft$df_get_obj_info_in,
      p_local_validation_criteria: ^fst$goi_validation_criteria;

    status.normal := TRUE;
    NEXT p_get_object_info_input IN p_send_parameters;
    IF p_get_object_info_input = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_get_object_info_input', status);
    ELSE
      pmp$get_pseudo_mainframe_id (p_get_object_info_input^.binary_mainframe_id);
      p_get_object_info_input^.evaluated_file_reference := evaluated_file_reference;
      p_get_object_info_input^.information_request := information_request;
      p_get_object_info_input^.system_privilege := system_privilege;
      p_get_object_info_input^.password_selector := password_selector;
      p_get_object_info_input^.subject_permit_count := subject_permit_count;
      p_get_object_info_input^.validation_ring := validation_ring;

      IF p_validation_criteria = NIL THEN
        p_get_object_info_input^.validation_criterion_count := 0;
        send_data_size := 0;
      ELSE
        p_get_object_info_input^.validation_criterion_count := UPPERBOUND (p_validation_criteria^);
        NEXT p_local_validation_criteria: [1 .. UPPERBOUND (p_validation_criteria^)] IN p_send_data;
        IF p_local_validation_criteria = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_validation_criteria in build_get_obj_info_send_buffer', status);
        ELSE
          p_local_validation_criteria^ := p_validation_criteria^;
          send_data_size := i#current_sequence_position (p_send_data);
        IFEND;
      IFEND;

      send_parameter_size := i#current_sequence_position (p_send_parameters);
    IFEND;
  PROCEND build_get_obj_info_send_buffer;

?? TITLE := '  build_mark_rel_candidate_buffer', EJECT ??

  PROCEDURE build_mark_rel_candidate_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         validation_ring: ost$valid_ring;
         archive_identification: pft$archive_identification;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_mark_rel_candidate_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password := password;
    p_send_parameters^.validation_ring := validation_ring;
    p_send_parameters^.archive_identification := archive_identification;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_mark_rel_candidate_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_mark_rel_candidate_buffer;

?? TITLE := '  build_permit_send_buffer', EJECT ??

  PROCEDURE build_permit_send_buffer
    (    path: pft$path;
         object_type: pft$object_types;
         system_privilege: boolean;
         permit_level: pft$permit_level;
         group: pft$group;
         permit_selections: pft$permit_selections;
         share_requirements: pft$share_requirements;
         application_info: pft$application_info;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR send_parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_permit_input: ^pft$df_permit_in;

    status.normal := TRUE;
    NEXT p_permit_input IN p_send_parameters;
    IF p_permit_input = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_permit_input in build_permit_send_buffer', status);
      RETURN; {----->
    ELSE
      p_permit_input^.path_length := UPPERBOUND (path);
      p_permit_input^.object_type := object_type;
      p_permit_input^.system_privilege := system_privilege;
      p_permit_input^.permit_level := permit_level;
      p_permit_input^.group := group;
      p_permit_input^.permit_selections := permit_selections;
      p_permit_input^.share_requirements := share_requirements;
      p_permit_input^.application_info := application_info;
    IFEND;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_permit_send_buffer', status);
      RETURN; {----->
    ELSE
      p_path^ := path;
    IFEND;

    send_parameter_size := i#current_sequence_position (p_send_parameters);
    status.normal := TRUE;
  PROCEND build_permit_send_buffer;

?? TITLE := '  build_purge_catalog_send_buffer', EJECT ??

  PROCEDURE build_purge_catalog_send_buffer
    (    path: pft$path;
         system_privilege: boolean;
         delete_option: pft$delete_option;
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR p_send_data: {i^/o} dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size);

    VAR
      p_path: ^pft$path,
      p_purge_catalog_input: ^pft$df_purge_catalog_in;

    NEXT p_purge_catalog_input IN p_send_parameters;
    p_purge_catalog_input^.system_privilege := system_privilege;
    p_purge_catalog_input^.delete_option := delete_option;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
      send_data_size := i#current_sequence_position (p_send_data);
    ELSE
      send_data_size := 0;
    IFEND;
    p_path^ := path;
    p_purge_catalog_input^.path_length := UPPERBOUND (path);

    send_parameters_size := i#current_sequence_position (p_send_parameters);
  PROCEND build_purge_catalog_send_buffer;

?? TITLE := '  build_purge_send_buffers', EJECT ??

  PROCEDURE build_purge_send_buffers
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         purge_cycle_options: pft$purge_cycle_options;
         system_privilege: boolean;
         validation_ring: ost$valid_ring;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR p_send_data: dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size);

    VAR
      p_path: ^pft$path,
      p_purge_input: ^pft$df_purge_in;

    RESET p_send_parameters;
    NEXT p_purge_input IN p_send_parameters;
    p_purge_input^.cycle_selector := cycle_selector;
    p_purge_input^.password := password;
    p_purge_input^.purge_cycle_options := purge_cycle_options;
    p_purge_input^.system_privilege := system_privilege;
    p_purge_input^.validation_ring := validation_ring;
    p_purge_input^.path_length := UPPERBOUND (path);

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      RESET p_send_data;
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
      send_data_size := i#current_sequence_position (p_send_data);
    ELSE
      send_data_size := 0;
    IFEND;
    p_path^ := path;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
  PROCEND build_purge_send_buffers;

?? TITLE := '  build_put_archive_entry_buffer', EJECT ??

  PROCEDURE build_put_archive_entry_buffer
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
         p_archive_array_entry: pft$p_archive_array_entry;
         p_amd: pft$p_amd;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR p_send_to_server_data: dft$p_send_data;
     VAR parameter_size: dft$send_parameter_size;
     VAR data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_amd: pft$p_amd,
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_put_archive_entry_inp;

    status.normal := TRUE;
    data_size := 0;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.archive_identification := archive_identification;
    p_send_parameters^.archive_array_entry := p_archive_array_entry^;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_put_archive_entry_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    IF p_amd = NIL THEN
      p_send_parameters^.amd_size := 0;
    ELSE
      p_send_parameters^.amd_size := #SIZE (p_amd^);
      NEXT p_local_amd: [[REP #SIZE (p_amd^) OF cell]] IN p_send_to_server_params;
      IF p_local_amd = NIL THEN
        NEXT p_local_amd: [[REP #SIZE (p_amd^) OF cell]] IN p_send_to_server_data;
        IF p_local_amd = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_amd in build_put_archive_entry_buffer', status);
          RETURN; {----->
        ELSE
          p_local_amd^ := p_amd^;
          data_size := i#current_sequence_position (p_send_to_server_data);
        IFEND;
      ELSE
        p_local_amd^ := p_amd^;
      IFEND;
    IFEND;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_put_archive_entry_buffer;

?? TITLE := '  build_put_archive_info_buffer', EJECT ??

  PROCEDURE build_put_archive_info_buffer
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         p_cycle_info_record: pft$p_info_record;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR p_send_to_server_data: dft$p_send_data;
     VAR parameter_size: dft$send_parameter_size;
     VAR data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_info_record: pft$p_info_record,
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_put_archive_info_inp;

    status.normal := TRUE;
    data_size := 0;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_put_archive_info_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    IF p_cycle_info_record = NIL THEN
      p_send_parameters^.info_size := 0;
    ELSE
      p_send_parameters^.info_size := p_cycle_info_record^.body_size;
      NEXT p_local_info_record: [[REP p_cycle_info_record^.body_size OF cell]] IN p_send_to_server_params;
      IF p_local_info_record = NIL THEN
        NEXT p_local_info_record: [[REP p_cycle_info_record^.body_size OF cell]] IN p_send_to_server_data;
        IF p_local_info_record = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_info_record in build_put_archive_info_buffer', status);
          RETURN; {----->
        ELSE
          p_local_info_record^ := p_cycle_info_record^;
          data_size := i#current_sequence_position (p_send_to_server_data);
        IFEND;
      ELSE
        p_local_info_record^ := p_cycle_info_record^;
      IFEND;
    IFEND;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_put_archive_info_buffer;

?? TITLE := '  build_put_cycle_info_buffer', EJECT ??

  PROCEDURE build_put_cycle_info_buffer
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         cycle_array_entry: pft$cycle_array_entry_version_2;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_put_cycle_info_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password_selector := password_selector;
    p_send_parameters^.cycle_array_entry := cycle_array_entry;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_put_cycle_info_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_put_cycle_info_buffer;

?? TITLE := '  build_put_item_info_send_bufs', EJECT ??

  PROCEDURE build_put_item_info_send_bufs
    (    backup_file_version: pft$backup_file_version;
         p_info_record: {input} pft$p_info_record;
         path: pft$complete_path;
         permit_level: pft$permit_level;
         selection_criteria: put$selection_criteria;
         restore_archive_information: boolean;
         audit_restorations: boolean;
         p_auditable_permits: {input} ^pft$auditable_permits;
         p_auditable_cycles: {input} ^pft$auditable_cycles;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR send_parameter_size: dft$send_parameter_size;
     VAR p_send_data: dft$p_send_data;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_info_record: ^pft$info_record,
      p_path: ^pft$path,
      p_put_item_info_input: ^pft$df_put_item_info_in;

    status.normal := TRUE;
    NEXT p_put_item_info_input IN p_send_parameters;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
    IFEND;
    p_path^ := path;
    p_put_item_info_input^.path_length := UPPERBOUND (path);

    IF p_info_record = NIL THEN
      p_put_item_info_input^.info_size := 0;
    ELSE
      p_put_item_info_input^.backup_file_version := backup_file_version;
      p_put_item_info_input^.info_size := p_info_record^.body_size;
      p_put_item_info_input^.permit_level := permit_level;
      p_put_item_info_input^.selection_criteria := selection_criteria;
      p_put_item_info_input^.restore_archive_information := restore_archive_information;
      p_put_item_info_input^.audit_restorations := audit_restorations;

      NEXT p_local_info_record: [[REP p_info_record^.body_size OF cell]] IN p_send_parameters;
      IF p_local_info_record = NIL THEN
        NEXT p_local_info_record: [[REP p_info_record^.body_size OF cell]] IN p_send_data;
        IF p_local_info_record = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_info_record in build_put_item_info_send_bufs', status);
          RETURN; {----->
        IFEND;
      IFEND;
      p_local_info_record^ := p_info_record^;
    IFEND;

    IF p_auditable_permits = NIL THEN
      p_put_item_info_input^.permit_count := 0;
    ELSE
      p_put_item_info_input^.permit_count := UPPERBOUND (p_auditable_permits^);
    IFEND;

    IF p_auditable_cycles = NIL THEN
      p_put_item_info_input^.cycle_count := 0;
    ELSE
      p_put_item_info_input^.cycle_count := UPPERBOUND (p_auditable_cycles^);
    IFEND;

    send_parameter_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_put_item_info_send_bufs;

?? TITLE := '  build_release_data_buffer', EJECT ??

  PROCEDURE build_release_data_buffer
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         p_release_data_info: {input} ^pft$release_data_info;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_rd_info: ^pft$release_data_info,
      p_send_parameters: ^pft$df_release_data_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password := password;

    p_send_parameters^.release_data_info_included := p_release_data_info <> NIL;
    IF p_release_data_info <> NIL THEN
      NEXT p_rd_info IN p_send_to_server_params;
      p_rd_info^ := p_release_data_info^;
    IFEND;

    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_release_data_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_release_data_buffer;

?? TITLE := '  build_rep_archive_entry_buffer', EJECT ??

  PROCEDURE build_rep_archive_entry_buffer
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         archive_identification: pft$archive_identification;
         p_archive_array_entry: pft$p_archive_array_entry;
         p_amd: pft$p_amd;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR p_send_to_server_data: dft$p_send_data;
     VAR parameter_size: dft$send_parameter_size;
     VAR data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_amd: pft$p_amd,
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_replace_arch_entry_inp;

    status.normal := TRUE;
    data_size := 0;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.archive_identification := archive_identification;
    p_send_parameters^.archive_array_entry := p_archive_array_entry^;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_rep_archive_entry_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    IF p_amd = NIL THEN
      p_send_parameters^.amd_size := 0;
    ELSE
      p_send_parameters^.amd_size := #SIZE (p_amd^);
      NEXT p_local_amd: [[REP #SIZE (p_amd^) OF cell]] IN p_send_to_server_params;
      IF p_local_amd = NIL THEN
        NEXT p_local_amd: [[REP #SIZE (p_amd^) OF cell]] IN p_send_to_server_data;
        IF p_local_amd = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_amd in build_rep_archive_entry_buffer', status);
          RETURN; {----->
        ELSE
          p_local_amd^ := p_amd^;
          data_size := i#current_sequence_position (p_send_to_server_data);
        IFEND;
      ELSE
        p_local_amd^ := p_amd^;
      IFEND;
    IFEND;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_rep_archive_entry_buffer;

?? TITLE := '  build_rep_rem_me_fmd_buffer', EJECT ??

  PROCEDURE build_rep_rem_me_fmd_buffer
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         replace_existing_rem_media_fmd: boolean;
         p_file_media_descriptor: ^SEQ ( * );
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR p_send_to_server_data: dft$p_send_data;
     VAR parameter_size: dft$send_parameter_size;
     VAR data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_file_media_descriptor: ^SEQ ( * ),
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_replace_rem_me_fmd_inp;

    status.normal := TRUE;
    data_size := 0;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.cycle_selector := cycle_selector;
    p_send_parameters^.password_selector := password_selector;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_rep_rem_me_fmd_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;
    p_send_parameters^.replace_existing_rem_media_fmd := replace_existing_rem_media_fmd;

    IF p_file_media_descriptor = NIL THEN
      p_send_parameters^.file_media_descriptor_size := 0;
    ELSE
      p_send_parameters^.file_media_descriptor_size := #SIZE (p_file_media_descriptor^);
      NEXT p_local_file_media_descriptor: [[REP #SIZE (p_file_media_descriptor^) OF cell]] IN
            p_send_to_server_params;
      IF p_local_file_media_descriptor = NIL THEN
        NEXT p_local_file_media_descriptor: [[REP #SIZE (p_file_media_descriptor^) OF cell]] IN
              p_send_to_server_data;
        IF p_local_file_media_descriptor = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_file_media_descriptor in build_rep_rem_me_fmd_buffer', status);
          RETURN; {----->
        ELSE
          p_local_file_media_descriptor^ := p_file_media_descriptor^;
          data_size := i#current_sequence_position (p_send_to_server_data);
        IFEND;
      ELSE
        p_local_file_media_descriptor^ := p_file_media_descriptor^;
      IFEND;
    IFEND;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_rep_rem_me_fmd_buffer;

?? TITLE := '  build_resolve_send_buffer', EJECT ??

  PROCEDURE build_resolve_send_buffer
    (    path: pft$path;
         system_privilege: boolean;
         cycle_reference: fst$cycle_reference;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_resolve_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.system_privilege := system_privilege;
    p_send_parameters^.cycle_reference := cycle_reference;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_resolve_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_resolve_send_buffer;

?? TITLE := '  build_return_send_buffer', EJECT ??

  PROCEDURE build_return_send_buffer
    (    attached_pf_table_index: pft$attached_pf_table_index;
         file_modified: boolean;
         eoi_byte_address: amt$file_byte_address;
         server_sfid: gft$system_file_identifier;
         device_class: rmt$device_class;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size);

    VAR
      p_send_parameters: ^pft$df_return_inp;

    RESET p_send_to_server_params;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.attached_pf_table_index := attached_pf_table_index;
    pmp$get_pseudo_mainframe_id (p_send_parameters^.mainframe_id);
    p_send_parameters^.attached_for_write := file_modified;
    p_send_parameters^.eoi_byte_address := eoi_byte_address;
    p_send_parameters^.server_sfid := server_sfid;
    p_send_parameters^.device_class := device_class;
    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_return_send_buffer;

?? TITLE := '  build_save_label_send_buffers', EJECT ??

  PROCEDURE build_save_label_send_buffers
    (    attached_pf_table_index: pft$attached_pf_table_index;
         system_authority: pft$system_authority;
         required_permission: pft$permit_options;
         p_file_label: {input} ^fmt$file_label;
         p_save_file_label_audit_seq: {input} ^SEQ ( * );
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR p_send_data: {i^/o} dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_file_label: ^fmt$file_label,
      p_save_file_label_input: ^pft$df_save_file_label_in;

    status.normal := TRUE;
    NEXT p_save_file_label_input IN p_send_parameters;
    p_save_file_label_input^.attached_pf_table_index := attached_pf_table_index;
    p_save_file_label_input^.system_authority := system_authority;
    p_save_file_label_input^.required_permission := required_permission;
    p_save_file_label_input^.audit := p_save_file_label_audit_seq <> NIL;

    IF p_file_label = NIL THEN
      p_save_file_label_input^.file_label_size := 0;
    ELSE
      NEXT p_local_file_label: [[REP #SIZE (p_file_label^) OF cell]] IN p_send_parameters;
      IF p_local_file_label = NIL THEN
        NEXT p_local_file_label: [[REP #SIZE (p_file_label^) OF cell]] IN p_send_data;
        IF p_local_file_label = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
                'NIL p_local_file_label in build_save_label_send_buffers', status);
          RETURN; {----->
        IFEND;
      IFEND;

      p_local_file_label^ := p_file_label^;
      p_save_file_label_input^.file_label_size := #SIZE (p_file_label^);
    IFEND;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_save_label_send_buffers;

?? TITLE := '  build_save_rel_label_send_bufs', EJECT ??

  PROCEDURE build_save_rel_label_send_bufs
    (    path: pft$complete_path;
         cycle_selector: pft$cycle_selector;
         password_selector: pft$password_selector;
         p_file_label: {input^} ^fmt$file_label;
         validation_ring: ost$valid_ring;
         update_cycle_statistics: boolean;
         p_save_label_audit_info: {input} ^pft$save_label_audit_info;
     VAR p_send_parameters: {i^/o} dft$p_send_parameters;
     VAR p_send_data: {i^/o} dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_local_file_label: ^fmt$file_label,
      p_path: ^pft$path,
      p_save_released_label_input: ^pft$df_save_released_label_in;

    status.normal := TRUE;
    NEXT p_save_released_label_input IN p_send_parameters;
    p_save_released_label_input^.cycle_selector := cycle_selector;
    p_save_released_label_input^.password_selector := password_selector;
    p_save_released_label_input^.validation_ring := validation_ring;
    p_save_released_label_input^.update_cycle_statistics := update_cycle_statistics;
    p_save_released_label_input^.audit := p_save_label_audit_info <> NIL;

    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_data;
    IFEND;
    p_path^ := path;
    p_save_released_label_input^.path_length := UPPERBOUND (path);

    NEXT p_local_file_label: [[REP #SIZE (p_file_label^) OF cell]] IN p_send_parameters;
    IF p_local_file_label = NIL THEN
      NEXT p_local_file_label: [[REP #SIZE (p_file_label^) OF cell]] IN p_send_data;
      IF p_local_file_label = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_local_file_label in build_save_rel_label_send_bufs', status);
        RETURN; {----->
      IFEND;
    IFEND;
    p_local_file_label^ := p_file_label^;
    p_save_released_label_input^.file_label_size := #SIZE (p_file_label^);

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND build_save_rel_label_send_bufs;

?? TITLE := '  build_validate_pw_send_buffer', EJECT ??

  PROCEDURE build_validate_pw_send_buffer
    (    path: pft$path;
         password: pft$password;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR parameter_size: dft$send_parameter_size;
     VAR status: ost$status);

    VAR
      p_path: ^pft$path,
      p_send_parameters: ^pft$df_validate_password_inp;

    status.normal := TRUE;
    NEXT p_send_parameters IN p_send_to_server_params;
    p_send_parameters^.password := password;
    p_send_parameters^.path_length := UPPERBOUND (path);
    NEXT p_path: [1 .. UPPERBOUND (path)] IN p_send_to_server_params;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_path in build_validate_pw_send_buffer', status);
      RETURN; {----->
    IFEND;
    p_path^ := path;

    parameter_size := i#current_sequence_position (p_send_to_server_params);
  PROCEND build_validate_pw_send_buffer;

?? TITLE := '  change_file_path_table', EJECT ??
{ PURPOSE:
{   This procedure changes the file name or cycle number, associated with a
{   fsp$change_file request, in file management's path table.  This procedure is modeled
{   after process_change_file_list in pfm$r2_request_processor.

  PROCEDURE change_file_path_table
    (    path: pft$path;
         old_cycle_number: fst$cycle_number;
         file_changes: ^fst$file_changes;
         last_change_file_attempted: ost$non_negative_integers;
     VAR status: ost$status);

    VAR
      change_file_index: pft$array_index,
      cycle_reference: fst$cycle_reference,
      evaluated_file_reference: fst$evaluated_file_reference,
      found: boolean,
      new_cycle_entry: boolean,
      new_object_entry: boolean,
      new_name: fst$path_element,
      path_index: fst$path_index,
      space_index: 1 .. fsc$max_path_element_size + 1;

    status.normal := TRUE;
    new_object_entry := FALSE;
    new_cycle_entry := FALSE;

  /make_changes/
    FOR change_file_index := 1 TO last_change_file_attempted DO
      CASE file_changes^ [change_file_index].selector OF
      = fsc$pf_name_change =
        IF NOT new_cycle_entry THEN
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
        IFEND;
        new_name.value := file_changes^ [change_file_index].pfn;
        #SCAN (pfv$space_character, file_changes^ [change_file_index].pfn, space_index, found);
        new_name.size := space_index - 1;
        fmp$change_recorded_file_name (evaluated_file_reference, new_name, status);
        IF status.normal THEN
          #SCAN (pfv$space_character, path [UPPERBOUND (path)], space_index, found);
          path_index := evaluated_file_reference.path_structure_size - space_index + 1;
          evaluated_file_reference.path_structure (path_index) := $CHAR (new_name.size);
          evaluated_file_reference.path_structure (path_index + 1, new_name.size) := new_name.value;
          evaluated_file_reference.path_structure_size := path_index + new_name.size;
        ELSE
          IF status.condition <> pfe$name_already_used THEN
            pfp$report_unexpected_status (status);
          IFEND;
          EXIT /make_changes/; {----->
        IFEND;
        new_object_entry := TRUE;

      = fsc$cycle_number_change =
        IF NOT new_object_entry THEN
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
        IFEND;
        evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
        evaluated_file_reference.cycle_reference.cycle_number := old_cycle_number;
        fmp$change_recorded_cycle_num (evaluated_file_reference,
              file_changes^ [change_file_index].cycle_number, status);
        IF status.normal THEN
          evaluated_file_reference.cycle_reference.cycle_number :=
                file_changes^ [change_file_index].cycle_number;
        ELSE
          IF status.condition <> pfe$duplicate_cycle THEN
            pfp$report_unexpected_status (status);
          IFEND;
          EXIT /make_changes/; {----->
        IFEND;
        new_cycle_entry := TRUE;

      ELSE
        ;
      CASEND;
    FOREND /make_changes/;
  PROCEND change_file_path_table;

?? TITLE := '  change_path_table', EJECT ??
{ PURPOSE:
{   This procedure changes the file name or cycle number, associated with a
{   change request, in file management's path table.  This procedure is modeled
{   after process_change_list in pfm$r2_request_processor.

  PROCEDURE change_path_table
    (    path: pft$path;
         old_cycle_number: fst$cycle_number;
         change_list: pft$change_list;
         last_change_attempted: ost$non_negative_integers;
     VAR status: ost$status);

    VAR
      change_index: pft$array_index,
      cycle_reference: fst$cycle_reference,
      evaluated_file_reference: fst$evaluated_file_reference,
      found: boolean,
      new_cycle_entry: boolean,
      new_object_entry: boolean,
      new_name: fst$path_element,
      path_index: fst$path_index,
      space_index: 1 .. fsc$max_path_element_size + 1;

    status.normal := TRUE;
    new_object_entry := FALSE;
    new_cycle_entry := FALSE;

  /make_changes/
    FOR change_index := 1 TO last_change_attempted DO
      CASE change_list [change_index].change_type OF
      = pfc$pf_name_change =
        IF NOT new_cycle_entry THEN
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
        IFEND;
        new_name.value := change_list [change_index].pfn;
        #SCAN (pfv$space_character, change_list [change_index].pfn, space_index, found);
        new_name.size := space_index - 1;
        fmp$change_recorded_file_name (evaluated_file_reference, new_name, status);
        IF status.normal THEN
          #SCAN (pfv$space_character, path [UPPERBOUND (path)], space_index, found);
          path_index := evaluated_file_reference.path_structure_size - space_index + 1;
          evaluated_file_reference.path_structure (path_index) := $CHAR (new_name.size);
          evaluated_file_reference.path_structure (path_index + 1, new_name.size) := new_name.value;
          evaluated_file_reference.path_structure_size := path_index + new_name.size;
        ELSE
          IF status.condition <> pfe$name_already_used THEN
            pfp$report_unexpected_status (status);
          IFEND;
          EXIT /make_changes/; {----->
        IFEND;
        new_object_entry := TRUE;

      = pfc$cycle_number_change =
        IF NOT new_object_entry THEN
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
        IFEND;
        evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
        evaluated_file_reference.cycle_reference.cycle_number := old_cycle_number;
        fmp$change_recorded_cycle_num (evaluated_file_reference, change_list [change_index].cycle_number,
              status);
        IF status.normal THEN
          evaluated_file_reference.cycle_reference.cycle_number := change_list [change_index].cycle_number;
        ELSE
          IF status.condition <> pfe$duplicate_cycle THEN
            pfp$report_unexpected_status (status);
          IFEND;
          EXIT /make_changes/; {----->
        IFEND;
        new_cycle_entry := TRUE;

      ELSE
        ;
      CASEND;
    FOREND /make_changes/;
  PROCEND change_path_table;

?? TITLE := '  check_local_attach', EJECT ??

  PROCEDURE check_local_attach
    (    path: pft$path;
         cycle_number: fst$cycle_number;
         lfn: amt$local_file_name;
         validation_ring: ost$valid_ring;
         usage_selector: pft$usage_selector;
         share_selector: pft$share_selector;
         called_by_attach: boolean;
         create_file: boolean;
     VAR status: ost$status);

    VAR
      attachment_options: array [1 .. 1] of fst$attachment_option,
      cycle_formerly_opened_info: fmt$cycle_formerly_opened_info,
      device_class: rmt$device_class,
      evaluated_file_reference: fst$evaluated_file_reference,
      p_cycle_description: ^fmt$cycle_description,
      path_handle: fmt$path_handle,
      path_table_cycle_info: fmt$path_table_cycle_info,
      process_pt_results: bat$process_pt_results,
      process_pt_work_list: bat$process_pt_work_list,
      selected_access: fst$file_access_options,
      selected_sharing: fst$file_access_options;

    pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
    evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
    evaluated_file_reference.cycle_reference.cycle_number := cycle_number;
    fmp$get_path_table_cycle_info ({inhibit_path_table_lock =} TRUE, evaluated_file_reference,
          path_table_cycle_info, status);

    IF status.normal THEN
      IF path_table_cycle_info.path_registered AND path_table_cycle_info.cycle_attachment_info.
            cycle_attached THEN

        attachment_options [1].selector := fsc$access_and_share_modes;
        IF usage_selector.option = pfc$default_usage_option THEN
          attachment_options [1].access_modes.selector := fsc$permitted_access_modes;
        ELSE
          attachment_options [1].access_modes.selector := fsc$specific_access_modes;
          #UNCHECKED_CONVERSION (usage_selector.usage_selections, attachment_options [1].access_modes.value);
        IFEND;

        IF share_selector.option = pfc$default_share_option THEN
          attachment_options [1].share_modes.selector := fsc$determine_from_access_modes;
        ELSE
          attachment_options [1].share_modes.selector := fsc$specific_share_modes;
          #UNCHECKED_CONVERSION (share_selector.share_selections, attachment_options [1].share_modes.value);
        IFEND;

        IF path_table_cycle_info.cycle_device_info.device_assigned THEN
          device_class := path_table_cycle_info.cycle_device_info.device_class;
          cycle_formerly_opened_info := path_table_cycle_info.cycle_device_info.cycle_formerly_opened_info;
        ELSE
          device_class := rmc$mass_storage_device;
          cycle_formerly_opened_info.cycle_previously_opened := FALSE;
        IFEND;

        IF status.normal THEN
          pfp$pick_modes_for_open (evaluated_file_reference, ^attachment_options,
                path_table_cycle_info.cycle_attachment_info.allowed_access,
                path_table_cycle_info.cycle_attachment_info.required_sharing,
                path_table_cycle_info.setfa_access_modes, device_class, cycle_formerly_opened_info,
                called_by_attach, create_file, validation_ring, selected_access, selected_sharing, status);
        IFEND;

        IF status.normal THEN
          process_pt_work_list := $bat$process_pt_work_list [bac$record_path, bac$resolve_path,
                bac$inhibit_locking_pt];
          fmp$process_pt_request (process_pt_work_list, lfn, evaluated_file_reference, p_cycle_description,
                process_pt_results, status);

        IFEND;
      ELSE
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              ' PF says it is attached, but not BAM', status);
      IFEND;
    IFEND;
  PROCEND check_local_attach;

?? TITLE := '  create_client_file_tables', EJECT ??

{   The purpose of this procedure is to interface with the device manager to
{ create a system file table entry, and then to interface with the local file
{ manager to associate the attached permanent file with a local file name
{ for the job, on the local mainframe.

  PROCEDURE create_client_file_tables
    (    family_locator: pft$served_family_locator;
         client_job_id: dft$client_job_id;
         lfn: amt$local_file_name;
     VAR evaluated_file_reference: fst$evaluated_file_reference;
         validation_ring: ost$valid_ring;
         device_class: rmt$device_class;
         authority: pft$authority;
         server_file_output: pft$server_file_output;
         implicit_attach: boolean;
         p_file_label: fmt$p_file_label;
         p_removable_media_req_info: ^fmt$removable_media_req_info;
         p_volume_list: ^rmt$volume_list;
     VAR status: ost$status);

    CONST
      critical_message = TRUE,
      message_origin = pmc$msg_origin_system;

    VAR
      attached_pf_id: pft$attached_permanent_file_id,
      attached_for_write: boolean,
      bams_sfid: gft$system_file_identifier,
      client_sfid: gft$system_file_identifier,
      complemented_gfn: dmt$global_file_name,
      file_modified: boolean,
      file_space_limit_kind: sft$file_space_limit_kind,
      flush_pages: boolean,
      fs_path: fst$path,
      fs_path_size: fst$path_size,
      eoi: amt$file_byte_address,
      local_status: ost$status,
      pf_attachment_info: fmt$pf_attachment_info,
      server_sfid: gft$system_file_identifier;

    IF device_class = rmc$mass_storage_device THEN
      dfp$complement_gfn (server_file_output.global_file_name, complemented_gfn);
      dmp$create_client_sft (complemented_gfn, server_file_output.usage_selections,
            server_file_output.share_selections, dmc$attach_or_create, server_file_output.dm_parameters,
            family_locator.served_family_table_index, family_locator.server_mainframe_id, client_sfid,
            status);
      IF status.normal THEN
        {
        { Build attached pf id.
        {
        attached_pf_id.family_location := pfc$server_mainframe;
        attached_pf_id.server_attached_pf_table_index := server_file_output.attached_pf_table_index;
        attached_pf_id.served_family_table_index := family_locator.served_family_table_index;
        attached_pf_id.server_lifetime := dfv$served_family_table_root.
              p_family_list_pointer_array^ [family_locator.served_family_table_index.pointers_index].
              p_served_family_list^ [family_locator.served_family_table_index.family_list_index].
              server_lifetime;
        IF dfv$use_server_io THEN
          bams_sfid := client_sfid;
        ELSE
          {
          { Lie to bam to use the 'remote' sfid, so that io will be performed
          { directly to the 'remote' file.  This only works in a single
          { mainframe test scenario.
          {
          bams_sfid := server_file_output.dm_parameters.remote_sfid;
        IFEND;
        IF (pfc$master_catalog_owner IN authority.ownership) AND
              ((server_file_output.usage_selections * pfv$write_usage) <> $pft$usage_selections []) THEN
          file_space_limit_kind := sfc$perm_file_space_limit;
        ELSE
          file_space_limit_kind := sfc$no_limit;
        IFEND;
        pf_attachment_info.apfid := attached_pf_id;
        pf_attachment_info.application_info := server_file_output.application_info;
        pf_attachment_info.implicit_attach := implicit_attach;
        pf_attachment_info.password_protected := server_file_output.password_protected;
        fmp$attach_file (lfn, complemented_gfn, complemented_gfn, bams_sfid,
              server_file_output.usage_selections, server_file_output.share_selections, validation_ring,
              file_space_limit_kind, p_file_label, ^pf_attachment_info, device_class,
              {p_removable_media_req_info} NIL, {p_volume_list} NIL, evaluated_file_reference, status);
        IF status.normal THEN
          syp$increment_server_file_count;
        ELSE
          flush_pages := (server_file_output.usage_selections <> $pft$usage_selections []);
          dmp$detach_server_file (client_sfid, flush_pages, {unconditional_detach=} FALSE, attached_for_write,
                eoi, server_sfid, local_status);
          pfp$process_unexpected_status (local_status);
          IF status.condition = ame$ring_validation_error THEN
            clp$convert_file_ref_to_string (evaluated_file_reference, {include_open_position =} FALSE,
                  fs_path, fs_path_size, local_status);
            osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$invalid_ring_access,
                  fs_path (1, fs_path_size), status);
          ELSEIF (status.condition = pfe$lfn_in_use) THEN
          ELSEIF (status.condition = rme$redundant_device_assignment) OR
                (status.condition = rme$device_assignment_conflict) THEN
            osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$lfn_in_use, lfn, status);
          ELSE
            clp$convert_file_ref_to_string (evaluated_file_reference, {include_open_position} FALSE, fs_path,
                  fs_path_size, local_status);
            pfp$report_unexpected_status (status);
            osp$append_status_parameter (osc$status_parameter_delimiter, fs_path (1, fs_path_size), status);
            pfp$log_error (status, -$pmt$ascii_logset [], message_origin, critical_message);
          IFEND;
        IFEND;
      ELSE
        clp$convert_file_ref_to_string (evaluated_file_reference, {include_open_position =} FALSE, fs_path,
              fs_path_size, local_status);
        pfp$report_unexpected_status (status);
        osp$append_status_parameter (osc$status_parameter_delimiter, fs_path (1, fs_path_size), status);
        pfp$log_error (status, -$pmt$ascii_logset [], message_origin, critical_message);
      IFEND;

    ELSEIF device_class = rmc$magnetic_tape_device THEN
      dmp$create_tape_file_sfid (p_removable_media_req_info, p_volume_list, client_sfid, status);
      IF status.normal THEN
        attached_pf_id.family_location := pfc$server_mainframe;
        attached_pf_id.server_attached_pf_table_index := server_file_output.attached_pf_table_index;
        attached_pf_id.served_family_table_index := family_locator.served_family_table_index;
        attached_pf_id.server_lifetime := dfv$served_family_table_root.
              p_family_list_pointer_array^ [family_locator.served_family_table_index.pointers_index].
              p_served_family_list^ [family_locator.served_family_table_index.family_list_index].
              server_lifetime;
        file_space_limit_kind := sfc$no_limit;
        pf_attachment_info.apfid := attached_pf_id;
        pf_attachment_info.application_info := server_file_output.application_info;
        pf_attachment_info.implicit_attach := implicit_attach;
        pf_attachment_info.password_protected := server_file_output.password_protected;
        fmp$attach_file (lfn, server_file_output.global_file_name, server_file_output.global_file_name,
              client_sfid, server_file_output.usage_selections, server_file_output.share_selections,
              validation_ring, file_space_limit_kind, p_file_label, ^pf_attachment_info, device_class,
              p_removable_media_req_info, p_volume_list, evaluated_file_reference, status);
        IF status.normal THEN
          syp$increment_server_file_count;
        IFEND;
      IFEND;
    IFEND;
  PROCEND create_client_file_tables;

?? TITLE := '  parse_attach_or_cref_receive', EJECT ??

  PROCEDURE [XDCL] parse_attach_or_cref_receive
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i/o} dft$p_receive_data;
     VAR evaluated_file_reference: fst$evaluated_file_reference;
     VAR action_attempted: pft$action_attempted;
     VAR action_taken: pft$attach_or_create_action;
     VAR authority: pft$authority;
     VAR allowed_access: fst$file_access_options;
     VAR selected_access: fst$file_access_options;
     VAR required_sharing: fst$file_access_options;
     VAR selected_sharing: fst$file_access_options;
     VAR device_class: rmt$device_class;
     VAR global_file_name: dmt$global_file_name;
     VAR new_global_file_name: dmt$global_file_name;
     VAR new_remote_sfid: gft$system_file_identifier;
     VAR label_used: boolean;
     VAR bytes_allocated: amt$file_byte_address;
     VAR p_file_label: ^fmt$file_label;
     VAR p_fmd: pft$p_fmd;
     VAR server_file_output: pft$server_file_output;
     VAR status: ost$status);

    VAR
      p_attach_or_create_output: ^pft$df_attach_or_create_out,
      p_server_file_output: ^pft$server_file_output,
      p_status: ^ost$status;

    NEXT p_attach_or_create_output IN p_receive_parameters;
    action_attempted := p_attach_or_create_output^.action_attempted;
    action_taken := p_attach_or_create_output^.action_taken;
    selected_access := p_attach_or_create_output^.selected_access;
    device_class := p_attach_or_create_output^.device_class;

    IF p_attach_or_create_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;

      IF (status.condition = pfe$recheck_client_mainframe) OR
            (status.condition = pfe$cycle_data_resides_offline) OR
            (status.condition = fse$device_class_conflict) THEN
        evaluated_file_reference := p_attach_or_create_output^.evaluated_file_reference;
      ELSEIF status.condition = pfe$tape_attached_on_client THEN
        evaluated_file_reference := p_attach_or_create_output^.evaluated_file_reference;
        device_class := p_attach_or_create_output^.device_class;
        global_file_name := p_attach_or_create_output^.global_file_name;
      IFEND;
    ELSE
      evaluated_file_reference := p_attach_or_create_output^.evaluated_file_reference;
      authority := p_attach_or_create_output^.authority;
      allowed_access := p_attach_or_create_output^.allowed_access;
      required_sharing := p_attach_or_create_output^.required_sharing;
      label_used := p_attach_or_create_output^.label_used;
      bytes_allocated := p_attach_or_create_output^.bytes_allocated;
      device_class := p_attach_or_create_output^.device_class;
      global_file_name := p_attach_or_create_output^.global_file_name;
      new_global_file_name := p_attach_or_create_output^.new_global_file_name;
      new_remote_sfid := p_attach_or_create_output^.new_remote_sfid;
      status.normal := TRUE;

      IF (action_taken = pfc$cycle_created) OR (action_taken = pfc$cycle_newly_attached) THEN
        NEXT p_server_file_output IN p_receive_parameters;
        server_file_output := p_server_file_output^;

        IF server_file_output.label_length = 0 THEN
          p_file_label := NIL;
        ELSEIF p_receive_data = NIL THEN
          NEXT p_file_label: [[REP server_file_output.label_length OF cell]] IN p_receive_parameters;
        ELSE
          NEXT p_file_label: [[REP server_file_output.label_length OF cell]] IN p_receive_data;
        IFEND;

        IF p_server_file_output^.rem_media_fmd_length = 0 THEN
          p_fmd := NIL;
        ELSE
          NEXT p_fmd: [[REP p_server_file_output^.rem_media_fmd_length OF cell]] IN p_receive_data;
        IFEND;
      IFEND;
    IFEND;
  PROCEND parse_attach_or_cref_receive;

?? TITLE := '  parse_attach_receive_buffers', EJECT ??

  PROCEDURE parse_attach_receive_buffers
    (VAR p_receive_parameters: dft$p_receive_parameters;
     VAR p_receive_data: dft$p_receive_data;
     VAR authority: pft$authority;
     VAR cycle_number: fst$cycle_number;
     VAR device_class: rmt$device_class;
     VAR cycle_damage_symptoms: fst$cycle_damage_symptoms;
     VAR global_file_name: dmt$global_file_name;
     VAR server_file_output: pft$server_file_output;
     VAR p_file_label: fmt$p_file_label;
     VAR p_fmd: pft$p_fmd;
     VAR status: ost$status);

    VAR
      p_attach_output: ^pft$df_attach_out,
      p_cycle_number: ^fst$cycle_number,
      p_server_file_output: ^pft$server_file_output,
      p_status: ^ost$status;

    NEXT p_attach_output IN p_receive_parameters;
    device_class := p_attach_output^.device_class;

    IF p_attach_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;

      NEXT p_cycle_number IN p_receive_parameters;
      cycle_number := p_cycle_number^;
      IF status.condition = pfe$tape_attached_on_client THEN
        device_class := p_attach_output^.device_class;
        global_file_name := p_attach_output^.global_file_name;
      IFEND;
    ELSE
      status.normal := TRUE;
      authority := p_attach_output^.authority;
      cycle_damage_symptoms := p_attach_output^.cycle_damage_symptoms;
      global_file_name := p_attach_output^.global_file_name;

      NEXT p_server_file_output IN p_receive_parameters;
      server_file_output := p_server_file_output^;
      cycle_number := p_server_file_output^.cycle_number;

      IF p_server_file_output^.label_length = 0 THEN
        p_file_label := NIL;
      ELSE
        IF (p_receive_data <> NIL) AND (#SIZE (p_receive_data^) > 0) THEN
          NEXT p_file_label: [[REP p_server_file_output^.label_length OF cell]] IN p_receive_data;
        ELSE
          NEXT p_file_label: [[REP p_server_file_output^.label_length OF cell]] IN p_receive_parameters;
        IFEND;
      IFEND;

      IF p_server_file_output^.rem_media_fmd_length = 0 THEN
        p_fmd := NIL;
      ELSE
        NEXT p_fmd: [[REP p_server_file_output^.rem_media_fmd_length OF cell]] IN p_receive_data;
      IFEND;
    IFEND;
  PROCEND parse_attach_receive_buffers;

?? TITLE := '  parse_change_receive_buffer', EJECT ??

  PROCEDURE parse_change_receive_buffer
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR cycle_number: fst$cycle_number;
     VAR device_class: rmt$device_class;
     VAR change_index: ost$non_negative_integers;
     VAR status: ost$status);

    VAR
      p_change_output: ^pft$df_change_out,
      p_status: ^ost$status;

    NEXT p_change_output IN p_receive_parameters;
    cycle_number := p_change_output^.cycle_number;
    device_class := p_change_output^.device_class;
    change_index := p_change_output^.change_index;

    IF p_change_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;
    ELSE
      status.normal := TRUE;
    IFEND;
  PROCEND parse_change_receive_buffer;

?? TITLE := '  parse_change_file_receive_buffer', EJECT ??

  PROCEDURE parse_change_file_receive
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR cycle_number: fst$cycle_number;
     VAR device_class: rmt$device_class;
     VAR change_file_index: ost$non_negative_integers;
     VAR status: ost$status);

    VAR
      p_change_file_output: ^pft$df_change_file_out,
      p_status: ^ost$status;

    NEXT p_change_file_output IN p_receive_parameters;
    cycle_number := p_change_file_output^.cycle_number;
    device_class := p_change_file_output^.device_class;
    change_file_index := p_change_file_output^.change_file_index;

    IF p_change_file_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;
    ELSE
      status.normal := TRUE;
    IFEND;
  PROCEND parse_change_file_receive;

?? TITLE := '  parse_define_data_params', EJECT ??

  PROCEDURE parse_define_data_params
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i/o} dft$p_receive_data;
     VAR mandated_modification_time: pft$mandated_modification_time;
     VAR data_residence: pft$data_residence;
     VAR authority: pft$authority;
     VAR bytes_allocated: amt$file_byte_address;
     VAR server_file_output: pft$server_file_output;
     VAR p_file_label: fmt$p_file_label);

    VAR
      p_define_data_output: ^pft$df_define_data_outp,
      p_server_file_output: ^pft$server_file_output;

    NEXT p_define_data_output IN p_receive_parameters;
    mandated_modification_time := p_define_data_output^.mandated_modification_time;
    data_residence := p_define_data_output^.data_residence;
    authority := p_define_data_output^.authority;
    bytes_allocated := p_define_data_output^.bytes_allocated;
    NEXT p_server_file_output IN p_receive_parameters;
    server_file_output := p_server_file_output^;

    IF p_server_file_output^.label_length = 0 THEN
      p_file_label := NIL;
    ELSE
      IF (p_receive_data <> NIL) AND (#SIZE (p_receive_data^) > 0) THEN
        NEXT p_file_label: [[REP p_server_file_output^.label_length OF cell]] IN p_receive_data;
      ELSE
        NEXT p_file_label: [[REP p_server_file_output^.label_length OF cell]] IN p_receive_parameters;
      IFEND;
    IFEND;
  PROCEND parse_define_data_params;

?? TITLE := '  parse_define_receive_params', EJECT ??

  PROCEDURE parse_define_receive_params
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR authority: pft$authority;
     VAR bytes_allocated: amt$file_byte_address;
     VAR server_file_output: pft$server_file_output);

    VAR
      p_define_output: ^pft$df_define_outp,
      p_server_file_output: ^pft$server_file_output;

    NEXT p_define_output IN p_receive_parameters;
    authority := p_define_output^.authority;
    bytes_allocated := p_define_output^.bytes_allocated;
    NEXT p_server_file_output IN p_receive_parameters;
    server_file_output := p_server_file_output^;
  PROCEND parse_define_receive_params;

?? TITLE := '  parse_get_fam_set_receive_param', EJECT ??

  PROCEDURE parse_get_fam_set_receive_param
    (VAR p_receive_from_server_params: dft$p_receive_parameters;
     VAR set_name: stt$set_name);

    VAR
      p_receive_parameters: ^pft$df_get_family_set_outp;

    NEXT p_receive_parameters IN p_receive_from_server_params;
    set_name := p_receive_parameters^.set_name;
  PROCEND parse_get_fam_set_receive_param;

?? TITLE := '  parse_get_famit_info_params', EJECT ??

  PROCEDURE parse_get_famit_info_params
    (VAR p_receive_from_server_params: dft$p_receive_parameters;
     VAR p_receive_data: dft$p_receive_data;
     VAR set_name: pft$name;
     VAR p_info: pft$p_info;
     VAR status: ost$status);

    VAR
      p_user_info: pft$p_info,
      p_server_info: pft$p_info,
      p_set_name: ^pft$name;

    status.normal := TRUE;
    NEXT p_set_name IN p_receive_from_server_params;
    set_name := p_set_name^;
    NEXT p_user_info: [[REP #SIZE (p_receive_data^) OF cell]] IN p_info;
    IF p_user_info = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$info_full, '', status);
      RETURN; {----->
    IFEND;
    NEXT p_server_info: [[REP #SIZE (p_receive_data^) OF cell]] IN p_receive_data;
    p_user_info^ := p_server_info^;
  PROCEND parse_get_famit_info_params;

?? TITLE := '  parse_get_mcat_receive_param', EJECT ??

  PROCEDURE parse_get_mcat_receive_param
    (VAR p_receive_from_server_params: dft$p_receive_parameters;
     VAR info_size: ost$segment_length);

    VAR
      p_receive_parameters: ^pft$df_get_mcat_info_outp;

    NEXT p_receive_parameters IN p_receive_from_server_params;
    info_size := p_receive_parameters^.info_size;
  PROCEND parse_get_mcat_receive_param;

?? TITLE := '  parse_get_obj_info_receive_bufs', EJECT ??

  PROCEDURE parse_get_obj_info_receive_bufs
    (    p_validation_criteria: {i/o^} ^fst$goi_validation_criteria;
         p_object_info: {input} ^fst$goi_object_information;
         queue_entry_location: dft$rpc_queue_entry_location;
     VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     VAR object_info_offset: ost$segment_offset;
     VAR p_object_information: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      p_client_object_info: ^SEQ ( * ),
      p_get_object_info_output: ^pft$df_get_obj_info_out,
      p_local_validation_criteria: ^fst$goi_validation_criteria,
      p_server_object_info: ^SEQ ( * ),
      p_status: ^ost$status;

    NEXT p_get_object_info_output IN p_receive_parameters;
    IF p_get_object_info_output = NIL THEN
      osp$set_status_abnormal (dfc$file_server_id, pfe$pf_system_error,
            'NIL p_get_object_info_output in parse_get_obj_info_receive_bufs', status);
      RETURN; {----->
    IFEND;

    object_info_offset := p_get_object_info_output^.object_info_offset;

    IF p_validation_criteria <> NIL THEN
      NEXT p_local_validation_criteria: [1 .. UPPERBOUND (p_validation_criteria^)] IN p_receive_data;
      IF p_local_validation_criteria = NIL THEN
        osp$set_status_abnormal (dfc$file_server_id, pfe$pf_system_error,
              'NIL p_validation_criteria in parse_get_obj_info_receive_bufs', status);
        RETURN; {----->
      IFEND;

      p_validation_criteria^ := p_local_validation_criteria^;
    IFEND;

    IF p_get_object_info_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      IF p_status = NIL THEN
        osp$set_status_abnormal (dfc$file_server_id, pfe$pf_system_error,
              'NIL p_status in parse_get_obj_info_receive_bufs', status);
        RETURN; {----->
      IFEND;

      IF p_status^.normal THEN
        status.normal := TRUE;
      ELSE
        status := p_status^;
      IFEND;
    ELSE
      status.normal := TRUE;
    IFEND;

    IF p_get_object_info_output^.rpc_segment_used THEN
      RESET p_object_information TO p_object_info;
      dfp$receive_server_rpc_segment (queue_entry_location, {server_segment_offset} 0,
            p_get_object_info_output^.info_size, p_object_information, status);
      IF (NOT status.normal) AND (status.condition = dfe$info_full) THEN
        osp$set_status_condition (pfe$info_full, status);
      IFEND;
    ELSE { The information is in the receive_data.
      IF p_validation_criteria = NIL THEN
        NEXT p_server_object_info: [[REP #SIZE (p_receive_data^) OF cell]] IN p_receive_data;
      ELSE
        NEXT p_server_object_info: [[REP (#SIZE (p_receive_data^) - #SIZE (p_validation_criteria^)) OF
              cell]] IN p_receive_data;
      IFEND;
      IF p_server_object_info = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_server_object_info in parse_get_obj_info_receive_bufs', status);
        RETURN; {----->
      IFEND;

      RESET p_object_information TO p_object_info;
      NEXT p_client_object_info: [[REP #SIZE (p_server_object_info^) OF cell]] IN p_object_information;
      IF p_client_object_info = NIL THEN
        osp$set_status_condition (pfe$info_full, status);
      ELSE
        p_client_object_info^ := p_server_object_info^;
      IFEND;
    IFEND;
  PROCEND parse_get_obj_info_receive_bufs;

?? TITLE := '  parse_purge_receive_buffer', EJECT ??

  PROCEDURE parse_purge_receive_buffer
    (VAR p_receive_parameters: dft$p_receive_parameters;
     VAR authority: pft$authority;
     VAR device_class: rmt$device_class;
     VAR bytes_released: amt$file_byte_address;
     VAR status: ost$status);

    VAR
      p_purge_output: ^pft$df_purge_out,
      p_status: ^ost$status;

    NEXT p_purge_output IN p_receive_parameters;
    authority := p_purge_output^.authority;
    device_class := p_purge_output^.device_class;

    IF p_purge_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;
    ELSE
      bytes_released := p_purge_output^.bytes_released;
      status.normal := TRUE;
    IFEND;
  PROCEND parse_purge_receive_buffer;

?? TITLE := '  parse_put_item_info_receipts', EJECT ??

  PROCEDURE parse_put_item_info_receipts
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     VAR audit_restorations: boolean;
     VAR all_permits_restored: boolean;
     VAR p_auditable_permits: ^pft$auditable_permits;
     VAR p_auditable_cycles: ^pft$auditable_cycles;
     VAR status: ost$status);

    VAR
      p_local_auditable_cycles: ^pft$auditable_cycles,
      p_local_auditable_permits: ^pft$auditable_permits,
      p_put_item_info_output: ^pft$df_put_item_info_out,
      p_status: ^ost$status;

    NEXT p_put_item_info_output IN p_receive_parameters;
    audit_restorations := p_put_item_info_output^.audit_restorations;
    all_permits_restored := p_put_item_info_output^.all_permits_restored;

    IF p_put_item_info_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;
    ELSE
      status.normal := TRUE;
    IFEND;

    IF p_put_item_info_output^.auditable_permits THEN
      NEXT p_local_auditable_permits: [1 .. UPPERBOUND (p_auditable_permits^)] IN p_receive_data;
      IF p_local_auditable_permits = NIL THEN
        p_auditable_permits := NIL;
      ELSE
        p_auditable_permits^ := p_local_auditable_permits^;
      IFEND;
    ELSE
      p_auditable_permits := NIL;
    IFEND;

    IF p_put_item_info_output^.auditable_cycles THEN
      NEXT p_local_auditable_cycles: [1 .. UPPERBOUND (p_auditable_cycles^)] IN p_receive_data;
      IF p_local_auditable_cycles = NIL THEN
        p_auditable_cycles := NIL;
      ELSE
        p_auditable_cycles^ := p_local_auditable_cycles^;
      IFEND;
    ELSE
      p_auditable_cycles := NIL;
    IFEND;
  PROCEND parse_put_item_info_receipts;

?? TITLE := '  parse_resolve_receive_params', EJECT ??

  PROCEDURE parse_resolve_receive_params
    (VAR p_receive_from_server_params: dft$p_receive_parameters;
     VAR cycle_reference: fst$cycle_reference;
     VAR path_resolution: fst$path_resolution);

    VAR
      p_receive_parameters: ^pft$df_resolve_outp;

    NEXT p_receive_parameters IN p_receive_from_server_params;
    cycle_reference := p_receive_parameters^.cycle_reference;
    path_resolution := p_receive_parameters^.path_resolution;
  PROCEND parse_resolve_receive_params;

?? TITLE := '  parse_return_receive_params', EJECT ??

  PROCEDURE parse_return_receive_params
    (VAR p_receive_from_server_params: dft$p_receive_parameters;
     VAR authority: pft$authority;
     VAR bytes_allocated_change: sft$counter);

    VAR
      p_parameters: ^pft$df_return_outp;

    NEXT p_parameters IN p_receive_from_server_params;
    authority := p_parameters^.authority;
    bytes_allocated_change := p_parameters^.bytes_allocated_change;

  PROCEND parse_return_receive_params;

?? TITLE := '  parse_save_label_receive_bufs', EJECT ??

  PROCEDURE parse_save_label_receive_bufs
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     VAR p_save_file_label_audit_seq: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      p_client_complete_path: ^pft$complete_path,
      p_client_save_label_audit_info: ^pft$save_label_audit_info,
      p_save_label_output: ^pft$df_save_label_out,
      p_server_complete_path: ^pft$complete_path,
      p_server_save_label_audit_info: ^pft$save_label_audit_info,
      p_status: ^ost$status;

    NEXT p_save_label_output IN p_receive_parameters;

    IF p_save_label_output^.audit THEN
      NEXT p_server_save_label_audit_info IN p_receive_parameters;
      NEXT p_server_complete_path: [1 .. p_server_save_label_audit_info^.file_path_count] IN
            p_receive_parameters;
      IF p_server_complete_path = NIL THEN
        NEXT p_server_complete_path: [1 .. p_server_save_label_audit_info^.file_path_count] IN p_receive_data;
      IFEND;

      RESET p_save_file_label_audit_seq;
      NEXT p_client_save_label_audit_info IN p_save_file_label_audit_seq;
      IF p_client_save_label_audit_info = NIL THEN
        p_save_file_label_audit_seq := NIL;
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_client_save_label_audit_info in parse_save_label_receive_bufs', status);
        RETURN; {----->
      IFEND;

      NEXT p_client_complete_path: [1 .. p_server_save_label_audit_info^.file_path_count] IN
            p_save_file_label_audit_seq;
      IF p_client_complete_path = NIL THEN
        p_save_file_label_audit_seq := NIL;
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_client_complete_path in parse_save_label_receive_bufs', status);
        RETURN; {----->
      IFEND;

      p_client_complete_path^ := p_server_complete_path^;
      p_client_save_label_audit_info^ := p_server_save_label_audit_info^;
    ELSE
      p_save_file_label_audit_seq := NIL;
    IFEND;

    IF p_save_label_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      IF p_status = NIL THEN
        NEXT p_status IN p_receive_data;
      IFEND;
      status := p_status^;
    ELSE
      status.normal := TRUE;
    IFEND;
  PROCEND parse_save_label_receive_bufs;

?? TITLE := '  parse_save_rel_label_receipt', EJECT ??

  PROCEDURE parse_save_rel_label_receipt
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_save_label_audit_info: ^pft$save_label_audit_info;
     VAR status: ost$status);

    VAR
      p_save_label_output: ^pft$df_save_label_out,
      p_server_save_label_audit_info: ^pft$save_label_audit_info,
      p_status: ^ost$status;

    NEXT p_save_label_output IN p_receive_parameters;
    IF p_save_label_output^.audit THEN
      NEXT p_server_save_label_audit_info IN p_receive_parameters;
      p_save_label_audit_info^ := p_server_save_label_audit_info^;
    ELSE
      p_save_label_audit_info := NIL;
    IFEND;

    IF p_save_label_output^.status_included THEN
      NEXT p_status IN p_receive_parameters;
      status := p_status^;
    ELSE
      status.normal := TRUE;
    IFEND;
  PROCEND parse_save_rel_label_receipt;

?? TITLE := '  purge_server_file', EJECT ??

  PROCEDURE purge_server_file
    (    path: pft$path;
         cycle_selector: pft$cycle_selector;
         password: pft$password;
         purge_cycle_options: pft$purge_cycle_options;
         system_privilege: boolean;
         validation_ring: ost$valid_ring;
         queue_entry_location: dft$rpc_queue_entry_location;
     VAR p_send_parameters: dft$p_send_parameters;
     VAR p_send_data: dft$p_send_data;
     VAR p_receive_parameters: dft$p_receive_parameters;
     VAR status: ost$status);

{ How about sending gfn over as a verification?

    VAR
      p_receive_data: dft$p_receive_data,
      send_data_size: dft$send_data_size,
      send_parameters_size: dft$send_parameter_size;

    build_purge_send_buffers (path, cycle_selector, password, purge_cycle_options, system_privilege,
          validation_ring, p_send_parameters, p_send_data, send_parameters_size, send_data_size);

    dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_purge, send_parameters_size,
          send_data_size, p_receive_parameters, p_receive_data, status);
  PROCEND purge_server_file;

?? TITLE := '  return_server_file', EJECT ??

  PROCEDURE return_server_file
    (    attached_pf_table_index: pft$attached_pf_table_index;
         file_modified: boolean;
         eoi_byte_address: amt$file_byte_address;
         server_sfid: gft$system_file_identifier;
         device_class: rmt$device_class;
         queue_entry_location: dft$rpc_queue_entry_location;
     VAR p_send_to_server_params: dft$p_send_parameters;
     VAR p_receive_from_server_params: dft$p_receive_parameters;
     VAR status: ost$status);

{ How about sending gfn over as a verification?

    VAR
      parameter_size: dft$send_parameter_size,
      p_receive_data: dft$p_receive_data;

    build_return_send_buffer (attached_pf_table_index, file_modified, eoi_byte_address, server_sfid,
          device_class, p_send_to_server_params, parameter_size);

    dfp$send_remote_procedure_call (queue_entry_location, dfc$r2_df_server_return, parameter_size, 0,
          p_receive_from_server_params, p_receive_data, status);
  PROCEND return_server_file;

?? TITLE := '  validate_path_table_change', EJECT ??

{  This procedure verifies the file name, or cycle number associated with a
{  change request may be changed in the path table.
{  This is done prior to going to the server, so that upon return from
{  the server, the actual change to the path table should work.

  PROCEDURE validate_path_table_change
    (    path: pft$path;
         change_list: pft$change_list;
     VAR status: ost$status);

    VAR
      change_index: integer,
      evaluated_file_reference: fst$evaluated_file_reference,
      fs_path: fst$path,
      fs_path_size: fst$path_size,
      new: pft$change_descriptor,
      new_file_object: boolean,
      p_new_path: ^pft$path,
      path_table_cycle_info: fmt$path_table_cycle_info;

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

  /validate_changes/
    FOR change_index := 1 TO UPPERBOUND (change_list) DO
      new := change_list [change_index];

      CASE new.change_type OF
      = pfc$pf_name_change =
        PUSH p_new_path: [1 .. UPPERBOUND (path)];
        p_new_path^ := path;
        p_new_path^ [UPPERBOUND (path)] := new.pfn;
        pfp$convert_pft$path_to_fs_str (p_new_path^, evaluated_file_reference);
        evaluated_file_reference.cycle_reference.specification := fsc$low_cycle;
        fmp$get_path_table_cycle_info ({inhibit_path_table_lock =} TRUE, evaluated_file_reference,
              path_table_cycle_info, status);
        IF status.normal THEN
          IF path_table_cycle_info.path_registered THEN
            pfp$convert_pft$path_to_fs_path (p_new_path^, fs_path, fs_path_size);
            osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$name_already_used,
                  fs_path (1, fs_path_size), status);
            EXIT /validate_changes/; {----->
          IFEND;
        ELSE
          pfp$report_unexpected_status (status);
          EXIT /validate_changes/; {----->
        IFEND;
        new_file_object := TRUE;

      = pfc$cycle_number_change =
        IF new_file_object THEN
          {
          { The new file name validated; the new cycle cannot be registered.
          {
        ELSE
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
          evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
          evaluated_file_reference.cycle_reference.cycle_number := new.cycle_number;
          fmp$get_path_table_cycle_info ({inhibit_path_table_lock =} TRUE, evaluated_file_reference,
                path_table_cycle_info, status);
          IF status.normal THEN
            IF path_table_cycle_info.path_registered THEN
              pfp$convert_pft$path_to_fs_path (path, fs_path, fs_path_size);
              osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$duplicate_cycle,
                    fs_path (1, fs_path_size), status);
              osp$append_status_integer (osc$status_parameter_delimiter, new.cycle_number, 10, FALSE, status);
              EXIT /validate_changes/; {----->
            IFEND;
          ELSE
            EXIT /validate_changes/; {----->
          IFEND;
        IFEND;

      ELSE
        ;
      CASEND;
    FOREND /validate_changes/;
  PROCEND validate_path_table_change;

?? TITLE := '  validate_path_table_change_file', EJECT ??

{  This procedure verifies the file name, or cycle number associated with a
{  change request may be changed in the path table.
{  This is done prior to going to the server, so that upon return from
{  the server, the actual change to the path table should work.

  PROCEDURE validate_path_table_change_file
    (    path: pft$path;
         file_changes: ^fst$file_changes;
     VAR status: ost$status);

    VAR
      change_index: integer,
      evaluated_file_reference: fst$evaluated_file_reference,
      fs_path: fst$path,
      fs_path_size: fst$path_size,
      new: fst$file_change,
      new_file_object: boolean,
      p_new_path: ^pft$path,
      path_table_cycle_info: fmt$path_table_cycle_info;

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

  /validate_changes/
    FOR change_index := 1 TO UPPERBOUND (file_changes^) DO
      new := file_changes^ [change_index];

      CASE new.selector OF
      = fsc$pf_name_change =
        PUSH p_new_path: [1 .. UPPERBOUND (path)];
        p_new_path^ := path;
        p_new_path^ [UPPERBOUND (path)] := new.pfn;
        pfp$convert_pft$path_to_fs_str (p_new_path^, evaluated_file_reference);
        evaluated_file_reference.cycle_reference.specification := fsc$low_cycle;
        fmp$get_path_table_cycle_info ({inhibit_path_table_lock =} TRUE, evaluated_file_reference,
              path_table_cycle_info, status);
        IF status.normal THEN
          IF path_table_cycle_info.path_registered THEN
            pfp$convert_pft$path_to_fs_path (p_new_path^, fs_path, fs_path_size);
            osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$name_already_used,
                  fs_path (1, fs_path_size), status);
            EXIT /validate_changes/; {----->
          IFEND;
        ELSE
          pfp$report_unexpected_status (status);
          EXIT /validate_changes/; {----->
        IFEND;
        new_file_object := TRUE;

      = fsc$cycle_number_change =
        IF new_file_object THEN
          {
          { The new file name validated; the new cycle cannot be registered.
          {
        ELSE
          pfp$convert_pft$path_to_fs_str (path, evaluated_file_reference);
          evaluated_file_reference.cycle_reference.specification := fsc$cycle_number;
          evaluated_file_reference.cycle_reference.cycle_number := new.cycle_number;
          fmp$get_path_table_cycle_info ({inhibit_path_table_lock =} TRUE, evaluated_file_reference,
                path_table_cycle_info, status);
          IF status.normal THEN
            IF path_table_cycle_info.path_registered THEN
              pfp$convert_pft$path_to_fs_path (path, fs_path, fs_path_size);
              osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$duplicate_cycle,
                    fs_path (1, fs_path_size), status);
              osp$append_status_integer (osc$status_parameter_delimiter, new.cycle_number, 10, FALSE, status);
              EXIT /validate_changes/; {----->
            IFEND;
          ELSE
            EXIT /validate_changes/; {----->
          IFEND;
        IFEND;

      ELSE
        ;
      CASEND;
    FOREND /validate_changes/;
  PROCEND validate_path_table_change_file;

?? OLDTITLE, SKIP := 2 ??
MODEND pfm$r2_df_client_requests;
