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

{ PURPOSE:
{   This module processes the server side of permanent file requests
{   originating from the client and destined for the server.
{
{ DESIGN:
{   The general sequence is:
{   - Parse the receive buffer and get the pointer to the path.
{   - Get the name of the set containing the catalog and build a complete path.
{   - Pass the required parameters to the standard processor contained in
{     module pfm$r2_request_processor.
{   - Build the parameter and data buffers to return to the client.  On
{     requests returning only the normal VAR parameters, this is done
{     completely within this module.  On those interfaces (e.g. attach, define,
{     attach_or_create) requiring additional information from the catalog or
{     device manager, part of the buffer will be built within
{     pfm$r2_request_processor.
{
{ NOTE:
{   Requests within this module assume that the request was initiated on the
{   client by calling dfp$begin_remote_procedure_call and
{   dfp$send_remote_procedure_call.

?? NEWTITLE := '  Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc i#current_sequence_position
*copyc dfd$driver_queue_types
*copyc dfd$request_package
*copyc fse$open_validation_errors
*copyc pfe$error_condition_codes
*copyc pfe$internal_error_conditions
*copyc dft$rpc_parameters
*copyc fst$device_classes
*copyc fst$file_changes
*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$path
*copyc pft$purge_cycle_options
*copyc pft$release_data_info
*copyc pft$relink_server_file
*copyc pft$unique_volume_list
?? POP ??
*copyc dfp$reserve_server_rpc_segment
*copyc dmp$fetch_eoi
*copyc dmp$fetch_server_sft_info
*copyc dmp$set_eoi
*copyc osp$append_status_parameter
*copyc osp$get_set_name
*copyc osp$log_job_recovery_message
*copyc osp$log_job_recovery_status
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$system_error
*copyc pfp$convert_cycle_path_to_strng
*copyc pfp$initialize_object_info
*copyc pfp$internal_return_file
*copyc pfp$internal_save_file_label
*copyc pfp$lock_apfid
*copyc pfp$process_unexpected_status
*copyc pfp$r2_append_rem_media_vsn
*copyc pfp$r2_attach_file
*copyc pfp$r2_attach_or_create
*copyc pfp$r2_change
*copyc pfp$r2_change_cycle_damage
*copyc pfp$r2_change_cycle_date_time
*copyc pfp$r2_change_file
*copyc pfp$r2_change_res_to_releasable
*copyc pfp$r2_clear_cycle_attachments
*copyc pfp$r2_define
*copyc pfp$r2_define_catalog
*copyc pfp$r2_define_data
*copyc pfp$r2_delete_all_arch_entries
*copyc pfp$r2_delete_archive_entry
*copyc pfp$r2_delete_catalog_permit
*copyc pfp$r2_delete_permit
*copyc pfp$r2_get_item_info
*copyc pfp$r2_get_master_catalog_info
*copyc pfp$r2_get_multi_item_info
*copyc pfp$r2_get_object_info
*copyc pfp$r2_get_vol_condition_list
*copyc pfp$r2_mark_release_candidate
*copyc pfp$r2_permit
*copyc pfp$r2_permit_catalog
*copyc pfp$r2_purge
*copyc pfp$r2_purge_catalog
*copyc pfp$r2_put_archive_entry
*copyc pfp$r2_put_archive_info
*copyc pfp$r2_put_cycle_info
*copyc pfp$r2_put_item_info
*copyc pfp$r2_release_data
*copyc pfp$r2_replace_archive_entry
*copyc pfp$r2_replace_rem_media_fmd
*copyc pfp$r2_resolve_path
*copyc pfp$r2_save_released_file_label
*copyc pfp$r2_validate_password
*copyc pfp$unlock_apfid
*copyc pmp$convert_binary_unique_name
?? TITLE := '  [XDCL, #GATE] pfp$r2_df_server_app_rem_me_vsn', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_app_rem_me_vsn
    (VAR p_param_received_from_client: {i^/o} dft$p_receive_parameters;
     VAR p_data_from_client: {i^/o} dft$p_receive_data;
     VAR p_send_to_client_params: dft$p_send_parameters;
     VAR p_send_to_client_data: 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_complete_path: ^pft$complete_path,
      p_file_media_descriptor: ^SEQ ( * ),
      p_input_parameters: ^pft$df_append_rem_me_vsn_inp,
      p_path: ^pft$path;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      pfp$r2_append_rem_media_vsn (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.volume_descriptor, status);
    IFEND;
  PROCEND pfp$r2_df_server_app_rem_me_vsn;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_attach
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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 status: ost$status);

    VAR
      allowed_usage_selections: pft$usage_selections,
      cycle_number: fst$cycle_number,
      file_server_buffers: pft$file_server_buffers,
      p_attach_input: ^pft$df_attach_in,
      p_attach_output: ^pft$df_attach_out,
      p_complete_path: ^pft$complete_path,
      p_cycle_number: ^fst$cycle_number,
      p_file_server_buffers: pft$p_file_server_buffers,
      p_path: ^pft$path,
      p_status: ^ost$status,
      required_share_selections: pft$share_selections;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_attach_input IN p_receive_parameters;
    NEXT p_path: [1 .. p_attach_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_attach_input^.path_length] IN p_receive_data;
    IFEND;

    PUSH p_complete_path: [1 .. (p_attach_input^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    file_server_buffers.p_send_parameters := p_send_parameters;
    file_server_buffers.p_send_data := p_send_data;
    p_file_server_buffers := ^file_server_buffers;
    NEXT p_attach_output IN file_server_buffers.p_send_parameters;

    pfp$r2_attach_file (pfc$server_mainframe, p_attach_input^.mainframe_id, {lfn} osc$null_name,
          p_complete_path^, p_attach_input^.cycle_selector, p_attach_input^.password,
          p_attach_input^.update_catalog, p_attach_input^.update_cycle_statistics,
          p_attach_input^.usage_selector, p_attach_input^.share_selector, p_attach_input^.system_privilege,
          p_attach_input^.validation_ring, {allowed_device_classes} - $fst$device_classes [],
          p_attach_input^.allowed_cycle_damage_symptoms, p_attach_output^.device_class, cycle_number,
          allowed_usage_selections, required_share_selections, p_attach_output^.cycle_damage_symptoms,
          p_attach_output^.authority, p_attach_output^.global_file_name, p_file_server_buffers, status);

    IF status.normal THEN
      p_attach_output^.status_included := FALSE;
      send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
      send_data_size := i#current_sequence_position (file_server_buffers.p_send_data);
    ELSE
      NEXT p_status IN file_server_buffers.p_send_parameters;
      p_status^ := status;
      p_attach_output^.status_included := TRUE;

      NEXT p_cycle_number IN file_server_buffers.p_send_parameters;
      p_cycle_number^ := cycle_number;

      send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
      status.normal := TRUE;
    IFEND;
  PROCEND pfp$r2_df_server_attach;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_attach_or_cref
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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
      authority: pft$authority,
      catalog: boolean,
      catalog_recreated: boolean,
      evaluated_file_reference: fst$evaluated_file_reference,
      file_server_buffers: pft$file_server_buffers,
      p_attach_or_create_input: ^pft$df_attach_or_create_in,
      p_attach_or_create_output: ^pft$df_attach_or_create_out,
      p_attachment_options: ^fst$attachment_options,
      p_file_label: ^fmt$file_label,
      p_file_server_buffers: ^pft$file_server_buffers,
      p_path_table_cycle_info: ^fmt$path_table_cycle_info,
      p_status: ^ost$status;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_attach_or_create_input IN p_receive_parameters;

    IF p_attach_or_create_input^.number_of_attachment_options = 0 THEN
      p_attachment_options := NIL;
    ELSE
      NEXT p_attachment_options: [1 .. p_attach_or_create_input^.number_of_attachment_options] IN
            p_receive_parameters;
      IF p_attachment_options = NIL THEN
        NEXT p_attachment_options: [1 .. p_attach_or_create_input^.number_of_attachment_options] IN
              p_receive_data;
      IFEND;
    IFEND;

    IF p_attach_or_create_input^.file_label_size = 0 THEN
      p_file_label := NIL;
    ELSE
      NEXT p_file_label: [[REP p_attach_or_create_input^.file_label_size OF cell]] IN p_receive_parameters;
      IF p_file_label = NIL THEN
        NEXT p_file_label: [[REP p_attach_or_create_input^.file_label_size OF cell]] IN p_receive_data;
      IFEND;
    IFEND;

    IF p_attach_or_create_input^.path_table_info_present THEN
      NEXT p_path_table_cycle_info IN p_receive_parameters;
      IF p_path_table_cycle_info = NIL THEN
        NEXT p_path_table_cycle_info IN p_receive_data;
      IFEND;
    ELSE
      p_path_table_cycle_info := NIL;
    IFEND;

    evaluated_file_reference := p_attach_or_create_input^.evaluated_file_reference;
    file_server_buffers.p_send_parameters := p_send_parameters;
    file_server_buffers.p_send_data := p_send_data;
    p_file_server_buffers := ^file_server_buffers;

    NEXT p_attach_or_create_output IN file_server_buffers.p_send_parameters;

    pfp$r2_attach_or_create (pfc$server_mainframe, p_attach_or_create_input^.mainframe_id,
          p_attach_or_create_input^.validation_ring, p_attach_or_create_input^.system_privilege,
          p_attach_or_create_input^.exception_selection_info, p_attachment_options, p_file_label,
          p_path_table_cycle_info, p_attach_or_create_input^.catalog_cycle_attributes,
          evaluated_file_reference, p_attach_or_create_output^.action_attempted,
          p_attach_or_create_output^.action_taken, p_attach_or_create_output^.authority,
          p_attach_or_create_output^.allowed_access, p_attach_or_create_output^.selected_access,
          p_attach_or_create_output^.required_sharing, p_attach_or_create_output^.selected_sharing,
          p_attach_or_create_output^.device_class, p_attach_or_create_output^.global_file_name,
          p_attach_or_create_output^.new_global_file_name, p_attach_or_create_output^.new_remote_sfid,
          p_attach_or_create_output^.label_used, p_attach_or_create_output^.bytes_allocated,
          p_file_server_buffers, status);

    IF status.normal THEN
      p_attach_or_create_output^.evaluated_file_reference := evaluated_file_reference;
      p_attach_or_create_output^.status_included := FALSE;
      send_data_size := i#current_sequence_position (file_server_buffers.p_send_data);
    ELSE
      IF (status.condition = pfe$recheck_client_mainframe) OR
            (status.condition = pfe$cycle_data_resides_offline) OR
            (status.condition = fse$device_class_conflict) THEN
        p_attach_or_create_output^.evaluated_file_reference := evaluated_file_reference;
      IFEND;

      NEXT p_status IN file_server_buffers.p_send_parameters;
      p_status^ := status;
      p_attach_or_create_output^.status_included := TRUE;
      status.normal := TRUE;
    IFEND;

    send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
  PROCEND pfp$r2_df_server_attach_or_cref;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_change
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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_change_output: ^pft$df_change_out,
      p_complete_path: ^pft$complete_path,
      p_path: ^pft$path,
      p_status: ^ost$status;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_change_input IN p_receive_parameters;

    NEXT p_path: [1 .. p_change_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_change_input^.path_length] IN p_receive_data;
    IFEND;

    PUSH p_complete_path: [1 .. p_change_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    NEXT p_change_list: [1 .. p_change_input^.change_count] IN p_receive_parameters;
    IF p_change_list = NIL THEN
      NEXT p_change_list: [1 .. p_change_input^.change_count] IN p_receive_data;
    IFEND;

    NEXT p_change_output IN p_send_parameters;

    pfp$r2_change (pfc$server_mainframe, p_complete_path^, p_change_input^.cycle_selector,
          p_change_input^.password, p_change_input^.system_privilege, p_change_list^,
          p_change_output^.cycle_number, p_change_output^.device_class, p_change_output^.change_index,
          status);

    IF status.normal THEN
      p_change_output^.status_included := FALSE;
    ELSE
      NEXT p_status IN p_send_parameters;
      p_status^ := status;
      p_change_output^.status_included := TRUE;
      status.normal := TRUE;
    IFEND;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND pfp$r2_df_server_change;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_change_cy_dam
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_change_cy_dam_inp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_change_cycle_damage (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.password, p_input_parameters^.new_damage_symptoms, status);
    IFEND;

  PROCEND pfp$r2_df_server_change_cy_dam;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_change_cy_dt
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_change_cy_dt_inp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_change_cycle_date_time (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.password, p_input_parameters^.new_access_date_time,
            p_input_parameters^.new_creation_date_time, p_input_parameters^.new_modification_date_time,
            status);
    IFEND;

  PROCEND pfp$r2_df_server_change_cy_dt;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_change_file
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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
      file_changes: ^fst$file_changes,
      p_change_file_input: ^pft$df_change_file_in,
      p_change_file_output: ^pft$df_change_file_out,
      p_complete_path: ^pft$complete_path,
      p_path: ^pft$path,
      p_status: ^ost$status;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_change_file_input IN p_receive_parameters;

    NEXT p_path: [1 .. p_change_file_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_change_file_input^.path_length] IN p_receive_data;
    IFEND;

    PUSH p_complete_path: [1 .. p_change_file_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    NEXT file_changes: [1 .. p_change_file_input^.change_file_count] IN p_receive_parameters;
    IF file_changes = NIL THEN
      NEXT file_changes: [1 .. p_change_file_input^.change_file_count] IN p_receive_data;
    IFEND;

    NEXT p_change_file_output IN p_send_parameters;

    pfp$r2_change_file (pfc$server_mainframe, p_complete_path^, p_change_file_input^.cycle_selector,
          p_change_file_input^.password, p_change_file_input^.system_privilege, file_changes,
          p_change_file_output^.cycle_number, p_change_file_output^.device_class,
          p_change_file_output^.change_file_index, status);

    IF status.normal THEN
      p_change_file_output^.status_included := FALSE;
    ELSE
      NEXT p_status IN p_send_parameters;
      p_status^ := status;
      p_change_file_output^.status_included := TRUE;
      status.normal := TRUE;
    IFEND;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND pfp$r2_df_server_change_file;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_change_res_rel
    (VAR p_receive_parameters {i^/o} : dft$p_receive_parameters;
     VAR p_receive_data {i^/o} : dft$p_receive_data;
     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_residence_input: ^pft$df_change_residence_in,
      p_complete_path: ^pft$complete_path,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_change_residence_input IN p_receive_parameters;
    NEXT p_path: [1 .. p_change_residence_input^.path_length] IN p_receive_parameters;
    PUSH p_complete_path: [1 .. (p_change_residence_input^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_change_res_to_releasable (p_complete_path^, p_change_residence_input^.cycle_selector, status);
    IFEND;

  PROCEND pfp$r2_df_server_change_res_rel;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_clear_cy_att
    (VAR p_receive_parameters {i^/o} : dft$p_receive_parameters;
     VAR p_receive_data {i^/o} : dft$p_receive_data;
     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_clear_cycle_attach_input: ^pft$df_clear_cy_att_in,
      p_complete_path: ^pft$complete_path,
      p_path: ^pft$path;

    send_parameters_size := 0;
    send_data_size := 0;
    status.normal := TRUE;

    NEXT p_clear_cycle_attach_input IN p_receive_parameters;
    NEXT p_path: [1 .. p_clear_cycle_attach_input^.path_length] IN p_receive_parameters;
    PUSH p_complete_path: [1 .. p_clear_cycle_attach_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_clear_cycle_attachments (p_complete_path^, p_clear_cycle_attach_input^.cycle_selector,
            p_clear_cycle_attach_input^.password, status);
    IFEND;

  PROCEND pfp$r2_df_server_clear_cy_att;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_define
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      cycle_number: fst$cycle_number,
      file_server_buffers: pft$file_server_buffers,
      p_complete_path: ^pft$complete_path,
      p_file_server_buffers: pft$p_file_server_buffers,
      p_input_parameters: ^pft$df_define_inp,
      p_ms_request: ^fmt$mass_storage_request_info,
      p_output_parameters: ^pft$df_define_outp,
      p_path: ^pft$path,
      p_rem_media_request: ^fmt$removable_media_req_info,
      p_volume_list: ^rmt$volume_list;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;

    IF p_input_parameters^.mass_storage_request_included THEN
      NEXT p_ms_request IN p_param_received_from_client;
    ELSE
      p_ms_request := NIL;
    IFEND;

    IF p_input_parameters^.rem_media_request_included THEN
      NEXT p_rem_media_request IN p_param_received_from_client;
    ELSE
      p_rem_media_request := NIL;
    IFEND;

    IF p_input_parameters^.volume_list_included THEN
      NEXT p_volume_list: [1 .. p_input_parameters^.number_of_volumes] IN p_param_received_from_client;
    ELSE
      p_volume_list := NIL;
    IFEND;

    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      file_server_buffers.p_send_parameters := p_send_to_client_params;
      file_server_buffers.p_send_data := p_send_to_client_data;
      p_file_server_buffers := ^file_server_buffers;
      NEXT p_output_parameters IN file_server_buffers.p_send_parameters;
      pfp$r2_define ({family_location} pfc$server_mainframe, p_input_parameters^.mainframe_id,
            {lfn} osc$null_name, p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.password, p_input_parameters^.log,
            p_input_parameters^.catalog_cycle_attributes, p_input_parameters^.system_privilege,
            p_input_parameters^.validation_ring, p_input_parameters^.device_class, p_ms_request,
            p_rem_media_request, p_volume_list, cycle_number, p_output_parameters^.authority,
            p_output_parameters^.bytes_allocated, p_file_server_buffers, status);
    IFEND;

    IF status.normal THEN
      send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
    IFEND;

  PROCEND pfp$r2_df_server_define;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_define_catalog
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_catalog_type: ^pft$catalog_types,
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_define_catalog_inp,
      p_ms_request: ^fmt$mass_storage_request_info,
      p_path: ^pft$path,
      selected_catalog_type: pft$catalog_types;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;

    IF p_input_parameters^.catalog_type_selected THEN
      NEXT p_catalog_type IN p_param_received_from_client;
      selected_catalog_type := p_catalog_type^;
    ELSE
      selected_catalog_type := pfc$external_catalog;
    IFEND;

    IF p_input_parameters^.mass_storage_request_included THEN
      NEXT p_ms_request IN p_param_received_from_client;
    ELSE
      p_ms_request := NIL;
    IFEND;

    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      pfp$r2_define_catalog (p_complete_path^, p_input_parameters^.charge_id,
            p_input_parameters^.system_privilege, p_input_parameters^.catalog_type_selected,
            selected_catalog_type, p_ms_request, status);
    IFEND;

  PROCEND pfp$r2_df_server_define_catalog;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_define_data
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      file_server_buffers: pft$file_server_buffers,
      mandated_modification_time: pft$mandated_modification_time,
      p_complete_path: ^pft$complete_path,
      p_file_server_buffers: pft$p_file_server_buffers,
      p_input_parameters: ^pft$df_define_data_inp,
      p_ms_request: ^fmt$mass_storage_request_info,
      p_output_parameters: ^pft$df_define_data_outp,
      p_path: ^pft$path,
      p_volume_list: ^array [1 .. * ] of rmt$recorded_vsn;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;

    IF p_input_parameters^.mass_storage_request_included THEN
      NEXT p_ms_request IN p_param_received_from_client;
    ELSE
      p_ms_request := NIL;
    IFEND;

    IF p_input_parameters^.volume_list_length <> 0 THEN
      NEXT p_volume_list: [1 .. p_input_parameters^.volume_list_length] IN p_param_received_from_client;
    ELSE
      p_volume_list := NIL;
    IFEND;

    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      file_server_buffers.p_send_parameters := p_send_to_client_params;
      file_server_buffers.p_send_data := p_send_to_client_data;
      p_file_server_buffers := ^file_server_buffers;
      mandated_modification_time := p_input_parameters^.mandated_modification_time;
      NEXT p_output_parameters IN file_server_buffers.p_send_parameters;
      pfp$r2_define_data ({family_location =} pfc$server_mainframe, p_input_parameters^.mainframe_id,
            {lfn =} osc$null_name, p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.update_cycle_statistics, p_input_parameters^.password_selector,
            p_input_parameters^.validation_ring, p_ms_request, p_volume_list,
            p_input_parameters^.purge_cycle_options, p_input_parameters^.replace_cycle_data,
            p_input_parameters^.restore_selections, mandated_modification_time,
            p_output_parameters^.data_residence, p_output_parameters^.authority,
            p_output_parameters^.bytes_allocated, p_file_server_buffers, status);
    IFEND;

    IF status.normal THEN
      p_output_parameters^.mandated_modification_time := mandated_modification_time;
      send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
    IFEND;

  PROCEND pfp$r2_df_server_define_data;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_del_all_arc_en
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_delete_all_arch_ent_inp,
      p_path: ^pft$path;

    send_parameters_length := 0;
    data_size_to_send_to_client := 0;
    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_delete_all_arch_entries (p_complete_path^, p_input_parameters^.cycle_selector, status);
    IFEND;

  PROCEND pfp$r2_df_server_del_all_arc_en;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_del_arch_entry
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_delete_archive_entry_inp,
      p_path: ^pft$path;

    send_parameters_length := 0;
    data_size_to_send_to_client := 0;
    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_delete_archive_entry (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.archive_identification, status);
    IFEND;

  PROCEND pfp$r2_df_server_del_arch_entry;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_delete_permit
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_delete_permit_inp,
      p_path: ^pft$path;

    send_parameters_length := 0;
    data_size_to_send_to_client := 0;
    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      IF p_input_parameters^.object_type = pfc$file_object THEN
        pfp$r2_delete_permit (p_complete_path^, p_input_parameters^.system_privilege,
              p_input_parameters^.group, status);
      ELSEIF p_input_parameters^.object_type = pfc$catalog_object THEN
        pfp$r2_delete_catalog_permit (p_complete_path^, p_input_parameters^.system_privilege,
              p_input_parameters^.group, status);
      ELSE
      IFEND;
    IFEND;
  PROCEND pfp$r2_df_server_delete_permit;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_get_family_set
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_input_parameters: ^pft$df_get_family_set_inp,
      p_output_parameters: ^pft$df_get_family_set_outp,
      set_name: stt$set_name;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    osp$get_set_name (p_input_parameters^.family_name, set_name, status);

    IF status.normal THEN
      NEXT p_output_parameters IN p_send_to_client_params;
      p_output_parameters^.set_name := set_name;
      send_parameters_size := i#current_sequence_position (p_send_to_client_params);
    IFEND;

  PROCEND pfp$r2_df_server_get_family_set;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_get_famit_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      complete_path: array [pfc$set_path_index .. pfc$family_path_index] of pft$name,
      group: pft$group,
      p_info: pft$p_info,
      p_input_parameters: ^pft$df_get_mcat_info_inp,
      p_set_name: ^pft$name,
      path: array [pfc$family_name_index .. pfc$family_name_index] of pft$name;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    path [pfc$family_name_index] := p_input_parameters^.family_name;
    convert_path_to_complete_path (path, complete_path, status);
    IF status.normal THEN
      NEXT p_set_name IN p_send_to_client_params;
      p_set_name^ := complete_path [pfc$set_path_index];
      send_parameters_size := #SIZE (p_set_name^);
      NEXT p_info: [[REP dfc$maximum_user_data_area OF cell]] IN p_send_to_client_data;
      group.group_type := pfc$public;
      pfp$r2_get_item_info (complete_path, {system_privilege= } FALSE, group,
            p_input_parameters^.catalog_info_selections, $pft$file_info_selections [], p_info, status);
    IFEND;

    IF status.normal THEN
      send_data_size := i#current_sequence_position (p_info);
    IFEND;
  PROCEND pfp$r2_df_server_get_famit_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_get_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      done: boolean,
      p_complete_path: ^pft$complete_path,
      p_info: pft$p_info,
      p_input_parameters: ^pft$df_get_info_in,
      p_output_parameters: ^pft$df_get_info_out,
      p_path: ^pft$path,
      rpc_segment_reserved: boolean;

    send_parameters_size := 0;
    send_data_size := 0;
    rpc_segment_reserved := FALSE;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      NEXT p_info: [[REP dfc$maximum_user_data_area OF cell]] IN p_send_to_client_data;

      REPEAT
        done := TRUE;
        IF p_input_parameters^.info_selection = pfc$get_item_info THEN
          pfp$r2_get_item_info (p_complete_path^, p_input_parameters^.system_privilege,
                p_input_parameters^.group, p_input_parameters^.catalog_info_selections,
                p_input_parameters^.file_info_selections, p_info, status);
        ELSE
          pfp$r2_get_multi_item_info (p_complete_path^, p_input_parameters^.system_privilege,
                p_input_parameters^.group, p_input_parameters^.catalog_info_selections,
                p_input_parameters^.file_info_selections, {p_cycle_reservation_criteria} NIL, p_info, status);
        IFEND;

        IF status.normal THEN
          IF NOT rpc_segment_reserved THEN
            send_data_size := i#current_sequence_position (p_info);
          IFEND;
        ELSEIF status.condition = pfe$info_full THEN
          dfp$reserve_server_rpc_segment (p_info, status);
          done := NOT status.normal;
          rpc_segment_reserved := TRUE;
        IFEND;
      UNTIL done;
    IFEND;

    IF status.normal THEN
      NEXT p_output_parameters IN p_send_to_client_params;
      p_output_parameters^.info_size := i#current_sequence_position (p_info);
      send_parameters_size := #SIZE (p_output_parameters^);
    IFEND;
  PROCEND pfp$r2_df_server_get_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_get_mcat_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      complete_path: array [pfc$set_path_index .. pfc$family_path_index] of pft$name,
      p_info: pft$p_info,
      p_input_parameters: ^pft$df_get_mcat_info_inp,
      p_output_parameters: ^pft$df_get_mcat_info_outp,
      path: array [pfc$family_name_index .. pfc$family_name_index] of pft$name;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    path [pfc$family_name_index] := p_input_parameters^.family_name;
    convert_path_to_complete_path (path, complete_path, status);
    IF status.normal THEN
      dfp$reserve_server_rpc_segment (p_info, status);
      IF status.normal THEN
        pfp$r2_get_master_catalog_info (complete_path, p_input_parameters^.catalog_info_selections, p_info,
              status);
        IF status.normal THEN
          NEXT p_output_parameters IN p_send_to_client_params;
          p_output_parameters^.info_size := i#current_sequence_position (p_info);
          send_parameters_size := #SIZE (p_output_parameters^);
        IFEND;
      IFEND;
    IFEND;
  PROCEND pfp$r2_df_server_get_mcat_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_get_obj_info
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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 status: ost$status);

    VAR
      done: boolean,
      p_get_object_info_input: ^pft$df_get_obj_info_in,
      p_get_object_info_output: ^pft$df_get_obj_info_out,
      p_object_info: ^fst$goi_object_information,
      p_object_information: ^SEQ ( * ),
      p_status: ^ost$status,
      p_validation_criteria_input: ^fst$goi_validation_criteria,
      p_validation_criteria_output: ^fst$goi_validation_criteria;

    NEXT p_get_object_info_input IN p_receive_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);
      RETURN; {----->
    IFEND;

    NEXT p_get_object_info_output IN p_send_parameters;
    IF p_get_object_info_output = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'NIL p_get_object_info_output', status);
      RETURN; {----->
    IFEND;

    IF p_get_object_info_input^.validation_criterion_count = 0 THEN
      p_validation_criteria_output := NIL;
      NEXT p_object_information: [[REP dfc$maximum_user_data_area OF cell]] IN p_send_data;
    ELSE
      NEXT p_validation_criteria_input: [1 .. p_get_object_info_input^.validation_criterion_count] IN
            p_receive_data;
      IF p_validation_criteria_input = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_validation_criteria_input', status);
        RETURN; {----->
      IFEND;

      NEXT p_validation_criteria_output: [1 .. p_get_object_info_input^.validation_criterion_count] IN
            p_send_data;
      IF p_validation_criteria_output = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_validation_criteria_output', status);
        RETURN; {----->
      IFEND;

      p_validation_criteria_output^ := p_validation_criteria_input^;
      NEXT p_object_information: [[REP (dfc$maximum_user_data_area - #SIZE (p_validation_criteria_output^)) OF
            cell]] IN p_send_data;
    IFEND;

    IF p_object_information = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error, 'NIL p_object_information',
            status);
      RETURN; {----->
    IFEND;

    p_get_object_info_output^.rpc_segment_used := FALSE;

    REPEAT
      done := TRUE;
      RESET p_object_information;
      NEXT p_object_info IN p_object_information;
      IF p_object_info = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error, 'NIL p_object_info',
              status);
        RETURN; {----->
      ELSE
        pfp$initialize_object_info (p_object_info);
      IFEND;

      pfp$r2_get_object_info (pfc$server_mainframe, p_get_object_info_input^.binary_mainframe_id,
            p_get_object_info_input^.evaluated_file_reference, p_get_object_info_input^.information_request,
            p_get_object_info_input^.system_privilege, p_get_object_info_input^.password_selector,
            p_get_object_info_input^.subject_permit_count, p_get_object_info_input^.validation_ring,
            p_validation_criteria_output, p_object_info, p_object_information, status);
      IF NOT status.normal AND (status.condition = pfe$info_full) THEN
        dfp$reserve_server_rpc_segment (p_object_information, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;

        done := FALSE;
        p_get_object_info_output^.rpc_segment_used := TRUE;
      IFEND;
    UNTIL done;

    IF status.normal OR (status.condition <> pfe$pf_system_error) THEN
      p_get_object_info_output^.object_info_offset := #OFFSET (p_object_info);
      p_get_object_info_output^.info_size := i#current_sequence_position (p_object_information);

      IF status.normal THEN
        p_get_object_info_output^.status_included := FALSE;
      ELSE
        NEXT p_status IN p_send_parameters;
        IF p_status = NIL THEN
          osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error, 'NIL p_status',
                status);
          RETURN; {----->
        IFEND;

        p_get_object_info_output^.status_included := TRUE;
        p_status^ := status;
        status.normal := TRUE;
      IFEND;

      IF p_get_object_info_output^.rpc_segment_used THEN
        IF p_validation_criteria_output = NIL THEN
          send_data_size := 0;
        ELSE
          send_data_size := #SIZE (p_validation_criteria_output^);
        IFEND;
      ELSE
        IF p_validation_criteria_output = NIL THEN
          send_data_size := i#current_sequence_position (p_object_information);
        ELSE
          send_data_size := #SIZE (p_validation_criteria_output^) +
                i#current_sequence_position (p_object_information);
        IFEND;
      IFEND;

      send_parameters_size := i#current_sequence_position (p_send_parameters);
    IFEND;
  PROCEND pfp$r2_df_server_get_obj_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_get_vol_cl
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_number_of_volumes: ^amt$volume_number,
      p_output_volume_count: ^amt$volume_number,
      p_unique_volume_list: ^pft$unique_volume_list,
      p_volume_condition_list: ^fst$volume_condition_list;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_number_of_volumes IN p_param_received_from_client;

    NEXT p_unique_volume_list: [1 .. p_number_of_volumes^] IN p_param_received_from_client;

    NEXT p_output_volume_count IN p_send_to_client_params;
    p_output_volume_count^ := p_number_of_volumes^;

    NEXT p_volume_condition_list: [1 .. p_number_of_volumes^] IN p_send_to_client_params;

    pfp$r2_get_vol_condition_list (p_unique_volume_list^, p_volume_condition_list^);

    send_parameters_size := i#current_sequence_position (p_send_to_client_params);

  PROCEND pfp$r2_df_server_get_vol_cl;
?? TITLE := '  [XDCL, #GATE] pfp$r2_df_server_mark_rel_cand', EJECT ??

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_mark_rel_cand
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_mark_rel_candidate_inp,
      p_path: ^pft$path;

    send_parameters_length := 0;
    data_size_to_send_to_client := 0;
    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_mark_release_candidate (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.password, p_input_parameters^.validation_ring,
            p_input_parameters^.archive_identification, status);
    IFEND;

  PROCEND pfp$r2_df_server_mark_rel_cand;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_permit
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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 status: ost$status);

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

    NEXT p_permit_input IN p_receive_parameters;
    IF p_permit_input = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error, 'NIL p_permit_input',
            status);
      RETURN; {----->
    IFEND;

    NEXT p_path: [1 .. p_permit_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error, 'NIL p_path in permit',
            status);
      RETURN; {----->
    ELSE
      PUSH p_complete_path: [1 .. (p_permit_input^.path_length + 1)];
      convert_path_to_complete_path (p_path^, p_complete_path^, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    IF p_permit_input^.object_type = pfc$file_object THEN
      pfp$r2_permit (p_complete_path^, p_permit_input^.system_privilege, p_permit_input^.permit_level,
            p_permit_input^.group, p_permit_input^.permit_selections, p_permit_input^.share_requirements,
            p_permit_input^.application_info, status);
    ELSEIF p_permit_input^.object_type = pfc$catalog_object THEN
      pfp$r2_permit_catalog (p_complete_path^, p_permit_input^.system_privilege, p_permit_input^.permit_level,
            p_permit_input^.group, p_permit_input^.permit_selections, p_permit_input^.share_requirements,
            p_permit_input^.application_info, status);
    ELSE
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            'invalid object_type in permit', status);
      RETURN; {----->
    IFEND;

    send_parameters_size := 0;
    send_data_size := 0;
  PROCEND pfp$r2_df_server_permit;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_purge
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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
      authority: pft$authority,
      bytes_released: amt$file_byte_address,
      file_server_buffers: pft$file_server_buffers,
      p_complete_path: ^pft$complete_path,
      p_file_server_buffers: ^pft$file_server_buffers,
      p_path: ^pft$path,
      p_purge_input: ^pft$df_purge_in,
      p_purge_output: ^pft$df_purge_out,
      p_status: ^ost$status;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_purge_input IN p_receive_parameters;
    NEXT p_path: [1 .. p_purge_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_purge_input^.path_length] IN p_receive_data;
    IFEND;
    PUSH p_complete_path: [1 .. p_purge_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      file_server_buffers.p_send_parameters := p_send_parameters;
      file_server_buffers.p_send_data := p_send_data;
      p_file_server_buffers := ^file_server_buffers;
      NEXT p_purge_output IN file_server_buffers.p_send_parameters;
      pfp$r2_purge (p_complete_path^, p_purge_input^.cycle_selector, p_purge_input^.password,
            p_purge_input^.purge_cycle_options, p_purge_input^.system_privilege,
            p_purge_input^.validation_ring, p_purge_output^.authority, p_purge_output^.device_class,
            p_purge_output^.bytes_released, status);

      IF status.normal THEN
        p_purge_output^.status_included := FALSE;
      ELSE
        NEXT p_status IN file_server_buffers.p_send_parameters;
        p_status^ := status;
        p_purge_output^.status_included := TRUE;
      IFEND;

      send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
    IFEND;
  PROCEND pfp$r2_df_server_purge;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_purge_catalog
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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 status: ost$status);

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

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_purge_catalog_input IN p_receive_parameters;

    NEXT p_path: [1 .. p_purge_catalog_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_purge_catalog_input^.path_length] IN p_receive_data;
    IFEND;
    PUSH p_complete_path: [1 .. p_purge_catalog_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      pfp$r2_purge_catalog (p_complete_path^, p_purge_catalog_input^.system_privilege,
            p_purge_catalog_input^.delete_option, status);
    IFEND;
  PROCEND pfp$r2_df_server_purge_catalog;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_put_arch_entry
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_amd: pft$p_amd,
      p_archive_array_entry: pft$p_archive_array_entry,
      p_complete_path: ^pft$complete_path,
      p_info_record: pft$p_info_record,
      p_input_parameters: ^pft$df_put_archive_entry_inp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      NEXT p_amd: [[REP p_input_parameters^.amd_size OF cell]] IN p_param_received_from_client;
      IF p_amd = NIL THEN
        NEXT p_amd: [[REP p_input_parameters^.amd_size OF cell]] IN p_data_from_client;
        IF p_amd = NIL THEN
          osp$system_error (' Amd not found in pfp$r2_df_server_put_arch_entry', NIL);
        IFEND;
      IFEND;
    IFEND;

    IF status.normal THEN
      p_archive_array_entry := ^p_input_parameters^.archive_array_entry;
      pfp$r2_put_archive_entry (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.archive_identification, p_archive_array_entry, p_amd, status);
    IFEND;

  PROCEND pfp$r2_df_server_put_arch_entry;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_put_arch_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_cycle_info_record: pft$p_info_record,
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_put_archive_info_inp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      NEXT p_cycle_info_record: [[REP p_input_parameters^.info_size OF cell]] IN p_param_received_from_client;
      IF p_cycle_info_record = NIL THEN
        NEXT p_cycle_info_record: [[REP p_input_parameters^.info_size OF cell]] IN p_data_from_client;
        IF p_cycle_info_record = NIL THEN
          osp$system_error (' Archive_Info not found in pfp$r2_df_server_put_archive_info', NIL);
        IFEND;
      IFEND;
    IFEND;

    IF status.normal THEN
      pfp$r2_put_archive_info (p_complete_path^, p_input_parameters^.cycle_selector, p_cycle_info_record,
            status);
    IFEND;

  PROCEND pfp$r2_df_server_put_arch_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_put_cycle_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_put_cycle_info_inp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;

    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      pfp$r2_put_cycle_info (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.password_selector, p_input_parameters^.cycle_array_entry, status);
    IFEND;

  PROCEND pfp$r2_df_server_put_cycle_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_put_item_info
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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_auditable_cycles: ^pft$auditable_cycles,
      p_auditable_permits: ^pft$auditable_permits,
      p_complete_path: ^pft$complete_path,
      p_info_record: ^pft$info_record,
      p_path: ^pft$path,
      p_put_item_info_input: ^pft$df_put_item_info_in,
      p_put_item_info_output: ^pft$df_put_item_info_out,
      p_status: ^ost$status;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_put_item_info_input IN p_receive_parameters;

    NEXT p_path: [1 .. p_put_item_info_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_put_item_info_input^.path_length] IN p_receive_data;
    IFEND;

    PUSH p_complete_path: [1 .. p_put_item_info_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    NEXT p_info_record: [[REP p_put_item_info_input^.info_size OF cell]] IN p_receive_parameters;
    IF p_info_record = NIL THEN
      NEXT p_info_record: [[REP p_put_item_info_input^.info_size OF cell]] IN p_receive_data;
    IFEND;

    NEXT p_put_item_info_output IN p_send_parameters;
    p_put_item_info_output^.audit_restorations := p_put_item_info_input^.audit_restorations;
    p_put_item_info_output^.all_permits_restored := TRUE;

    IF p_put_item_info_input^.permit_count = 0 THEN
      p_auditable_permits := NIL;
    ELSE
      NEXT p_auditable_permits: [1 .. p_put_item_info_input^.permit_count] IN p_send_data;
      IF p_auditable_permits = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_auditable_permits in pfp$r2_df_server_put_item_info', status);
        RETURN; {----->
      IFEND;
    IFEND;

    IF p_put_item_info_input^.cycle_count = 0 THEN
      p_auditable_cycles := NIL;
    ELSE
      NEXT p_auditable_cycles: [1 .. p_put_item_info_input^.cycle_count] IN p_send_data;
      IF p_auditable_cycles = NIL THEN
        osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
              'NIL p_auditable_cycles in pfp$r2_df_server_put_item_info', status);
        RETURN; {----->
      IFEND;
    IFEND;

    pfp$r2_put_item_info (p_put_item_info_input^.backup_file_version, p_info_record, pfc$server_mainframe,
          p_complete_path^, p_put_item_info_input^.permit_level, p_put_item_info_input^.selection_criteria,
          p_put_item_info_input^.restore_archive_information, p_put_item_info_output^.audit_restorations,
          p_put_item_info_output^.all_permits_restored, p_auditable_permits, p_auditable_cycles, status);

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

    p_put_item_info_output^.auditable_permits := p_auditable_permits <> NIL;
    p_put_item_info_output^.auditable_cycles := p_auditable_cycles <> NIL;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND pfp$r2_df_server_put_item_info;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_release_data
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_release_data_inp,
      p_path: ^pft$path,
      p_rd_info: ^pft$release_data_info,
      p_rd_info_out: ^pft$release_data_info;

    send_parameters_length := 0;
    data_size_to_send_to_client := 0;
    NEXT p_input_parameters IN p_param_received_from_client;

    IF p_input_parameters^.release_data_info_included THEN
      NEXT p_rd_info IN p_param_received_from_client;
    ELSE
      p_rd_info := NIL;
    IFEND;

    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_release_data (p_complete_path^, p_input_parameters^.cycle_selector, p_input_parameters^.password,
            p_rd_info, status);
    IFEND;

    IF status.normal AND (p_rd_info <> NIL) THEN
      NEXT p_rd_info_out IN p_send_to_client_params;
      p_rd_info_out^ := p_rd_info^;
      send_parameters_length := i#current_sequence_position (p_send_to_client_params);
    IFEND;

  PROCEND pfp$r2_df_server_release_data;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_rep_arch_entry
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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_amd: pft$p_amd,
      p_archive_array_entry: pft$p_archive_array_entry,
      p_complete_path: ^pft$complete_path,
      p_info_record: pft$p_info_record,
      p_input_parameters: ^pft$df_replace_arch_entry_inp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      NEXT p_amd: [[REP p_input_parameters^.amd_size OF cell]] IN p_param_received_from_client;
      IF p_amd = NIL THEN
        NEXT p_amd: [[REP p_input_parameters^.amd_size OF cell]] IN p_data_from_client;
        IF p_amd = NIL THEN
          osp$system_error (' Amd not found in pfp$r2_df_server_rep_arch_entry', NIL);
        IFEND;
      IFEND;
    IFEND;

    IF status.normal THEN
      p_archive_array_entry := ^p_input_parameters^.archive_array_entry;
      pfp$r2_replace_archive_entry (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.archive_identification, p_archive_array_entry, p_amd, status);
    IFEND;

  PROCEND pfp$r2_df_server_rep_arch_entry;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_rep_rem_me_fmd
    (VAR p_param_received_from_client: {i^/o} dft$p_receive_parameters;
     VAR p_data_from_client: {i^/o} dft$p_receive_data;
     VAR p_send_to_client_params: dft$p_send_parameters;
     VAR p_send_to_client_data: 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
      error_message: string (80),
      error_message_length: integer,
      p_complete_path: ^pft$complete_path,
      p_file_media_descriptor: ^SEQ ( * ),
      p_input_parameters: ^pft$df_replace_rem_me_fmd_inp,
      p_path: ^pft$path;

    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);

    IF status.normal THEN
      NEXT p_file_media_descriptor: [[REP p_input_parameters^.file_media_descriptor_size OF cell]] IN
            p_param_received_from_client;
      IF p_file_media_descriptor = NIL THEN
        NEXT p_file_media_descriptor: [[REP p_input_parameters^.file_media_descriptor_size OF cell]] IN
              p_data_from_client;
        IF p_file_media_descriptor = NIL THEN
          STRINGREP (error_message, error_message_length, ' File_media_descriptor_size',
                p_input_parameters^.file_media_descriptor_size, ' too large pfp$r2_df_server_rep_rem_me_fmd');
          osp$system_error (error_message (1, error_message_length), NIL);
        IFEND;
      IFEND;
    IFEND;

    IF status.normal THEN
      pfp$r2_replace_rem_media_fmd (p_complete_path^, p_input_parameters^.cycle_selector,
            p_input_parameters^.password_selector, p_input_parameters^.replace_existing_rem_media_fmd,
            p_file_media_descriptor, status);
    IFEND;
  PROCEND pfp$r2_df_server_rep_rem_me_fmd;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_resolve
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      cycle_reference: fst$cycle_reference,
      path_resolution: fst$path_resolution,
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_resolve_inp,
      p_output_parameters: ^pft$df_resolve_outp,
      p_path: ^pft$path;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      cycle_reference := p_input_parameters^.cycle_reference;
      pfp$r2_resolve_path (p_complete_path^, p_input_parameters^.system_privilege, cycle_reference,
            path_resolution, status);
    IFEND;

    IF status.normal THEN
      NEXT p_output_parameters IN p_send_to_client_params;
      p_output_parameters^.cycle_reference := cycle_reference;
      p_output_parameters^.path_resolution := path_resolution;
      send_parameters_size := i#current_sequence_position (p_send_to_client_params);
    IFEND;

  PROCEND pfp$r2_df_server_resolve;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_return
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : 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
      file_server_buffers: pft$file_server_buffers,
      p_file_server_buffers: pft$p_file_server_buffers,
      p_input_parameters: ^pft$df_return_inp,
      p_output_parameters: ^pft$df_return_outp,
      server_eoi: amt$file_byte_address;

    status.normal := TRUE;
    send_parameters_size := 0;
    send_data_size := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    file_server_buffers.p_send_parameters := p_send_to_client_params;
    file_server_buffers.p_send_data := p_send_to_client_data;
    p_file_server_buffers := ^file_server_buffers;
    NEXT p_output_parameters IN file_server_buffers.p_send_parameters;
    IF (p_input_parameters^.device_class = rmc$mass_storage_device) AND
          p_input_parameters^.attached_for_write THEN
      dmp$fetch_eoi (p_input_parameters^.server_sfid, server_eoi, status);
      IF status.normal AND (server_eoi <> p_input_parameters^.eoi_byte_address) THEN
        dmp$set_eoi (p_input_parameters^.server_sfid, p_input_parameters^.eoi_byte_address, status);
      IFEND;
    IFEND;

    pfp$internal_return_file (p_input_parameters^.attached_pf_table_index, p_input_parameters^.mainframe_id,
          p_output_parameters^.authority, p_output_parameters^.bytes_allocated_change, status);

    IF status.normal THEN
      send_parameters_size := i#current_sequence_position (file_server_buffers.p_send_parameters);
    IFEND;

  PROCEND pfp$r2_df_server_return;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_save_label
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i/o} dft$p_receive_data;
     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
      apfid: pft$attached_permanent_file_id,
      p_client_complete_path: ^pft$complete_path,
      p_client_save_label_audit_info: ^pft$save_label_audit_info,
      p_file_label: ^fmt$file_label,
      p_save_file_label_audit_seq: ^SEQ ( * ),
      p_save_file_label_input: ^pft$df_save_file_label_in,
      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_file_label_input IN p_receive_parameters;
    apfid.family_location := pfc$local_mainframe;
    apfid.attached_pf_table_index := p_save_file_label_input^.attached_pf_table_index;

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

    IF p_save_file_label_input^.audit THEN
      PUSH p_save_file_label_audit_seq: [[pft$save_label_audit_info,
            REP UPPERVALUE (pft$file_path_count) OF pft$name]];
    ELSE
      p_save_file_label_audit_seq := NIL;
    IFEND;

    pfp$internal_save_file_label (apfid, p_save_file_label_input^.system_authority,
          p_save_file_label_input^.required_permission, p_file_label, p_save_file_label_audit_seq, status);

    NEXT p_save_label_output IN p_send_parameters;

    IF p_save_file_label_audit_seq = NIL THEN
      p_save_label_output^.audit := FALSE;
    ELSE
      RESET p_save_file_label_audit_seq;
      NEXT p_server_save_label_audit_info IN p_save_file_label_audit_seq;
      NEXT p_server_complete_path: [1 .. p_server_save_label_audit_info^.file_path_count] IN
            p_save_file_label_audit_seq;

      NEXT p_client_save_label_audit_info IN p_send_parameters;
      NEXT p_client_complete_path: [1 .. p_server_save_label_audit_info^.file_path_count] IN
            p_send_parameters;
      IF p_client_complete_path = NIL THEN
        NEXT p_client_complete_path: [1 .. p_server_save_label_audit_info^.file_path_count] IN p_send_data;
      IFEND;

      p_client_complete_path^ := p_server_complete_path^;
      p_client_save_label_audit_info^ := p_server_save_label_audit_info^;
      p_save_label_output^.audit := TRUE;
    IFEND;

    IF status.normal THEN
      p_save_label_output^.status_included := FALSE;
    ELSE
      NEXT p_status IN p_send_parameters;
      IF p_status = NIL THEN
        NEXT p_status IN p_send_data;
      IFEND;
      p_status^ := status;
      p_save_label_output^.status_included := TRUE;
      status.normal := TRUE;
    IFEND;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := i#current_sequence_position (p_send_data);
  PROCEND pfp$r2_df_server_save_label;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_save_rel_label
    (VAR p_receive_parameters: {i^/o} dft$p_receive_parameters;
     VAR p_receive_data: {i^/o} dft$p_receive_data;
     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_complete_path: ^pft$complete_path,
      p_file_label: ^fmt$file_label,
      p_path: ^pft$path,
      p_save_label_audit_info: ^pft$save_label_audit_info,
      p_save_released_label_input: ^pft$df_save_released_label_in,
      p_save_label_output: ^pft$df_save_label_out,
      p_status: ^ost$status;

    NEXT p_save_released_label_input IN p_receive_parameters;

    NEXT p_path: [1 .. p_save_released_label_input^.path_length] IN p_receive_parameters;
    IF p_path = NIL THEN
      NEXT p_path: [1 .. p_save_released_label_input^.path_length] IN p_receive_data;
    IFEND;

    PUSH p_complete_path: [1 .. p_save_released_label_input^.path_length + 1];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF NOT status.normal THEN
      send_parameters_size := 0;
      send_data_size := 0;
      RETURN; {----->
    IFEND;

    NEXT p_file_label: [[REP p_save_released_label_input^.file_label_size OF cell]] IN p_receive_parameters;
    IF p_file_label = NIL THEN
      NEXT p_file_label: [[REP p_save_released_label_input^.file_label_size OF cell]] IN p_receive_data;
    IFEND;

    NEXT p_save_label_output IN p_send_parameters;
    IF p_save_released_label_input^.audit THEN
      NEXT p_save_label_audit_info IN p_send_parameters;
    ELSE
      p_save_label_audit_info := NIL;
    IFEND;

    pfp$r2_save_released_file_label (p_complete_path^, p_save_released_label_input^.cycle_selector,
          p_save_released_label_input^.password_selector, p_file_label,
          p_save_released_label_input^.validation_ring, p_save_released_label_input^.update_cycle_statistics,
          p_save_label_audit_info, status);

    IF p_save_label_audit_info = NIL THEN
      RESET p_send_parameters;
      NEXT p_save_label_output IN p_send_parameters;
      p_save_label_output^.audit := FALSE;
    ELSE
      p_save_label_output^.audit := TRUE;
    IFEND;

    IF status.normal THEN
      p_save_label_output^.status_included := FALSE;
    ELSE
      NEXT p_status IN p_send_parameters;
      p_status^ := status;
      p_save_label_output^.status_included := TRUE;
      status.normal := TRUE;
    IFEND;

    send_parameters_size := i#current_sequence_position (p_send_parameters);
    send_data_size := 0;
  PROCEND pfp$r2_df_server_save_rel_label;

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

  PROCEDURE [XDCL, #GATE] pfp$r2_df_server_validate_pw
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      p_complete_path: ^pft$complete_path,
      p_input_parameters: ^pft$df_validate_password_inp,
      p_path: ^pft$path;

    send_parameters_length := 0;
    data_size_to_send_to_client := 0;
    NEXT p_input_parameters IN p_param_received_from_client;
    NEXT p_path: [1 .. p_input_parameters^.path_length] IN p_param_received_from_client;
    PUSH p_complete_path: [1 .. (p_input_parameters^.path_length + 1)];
    convert_path_to_complete_path (p_path^, p_complete_path^, status);
    IF status.normal THEN
      pfp$r2_validate_password (p_complete_path^, p_input_parameters^.password, status);
    IFEND;
  PROCEND pfp$r2_df_server_validate_pw;

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

{    This is the server companion procedure to the client procedure
{ pfp$relink_server_file.  This procedure performs the server side processing
{ during server job recovery, when the file is relinked to the client.  This
{ merely involves verifying that the file is still attached on the server, and
{ returning the required device manager information so that the client may be
{ updated.  The state of the file in the attached permanent file table is
{ updated to indicate 'normal'.
{

  PROCEDURE [XDCL, #GATE] pfp$relink_file_to_client
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    VAR
      error_string: string (100),
      error_string_length: integer,
      file_server_buffers: pft$file_server_buffers,
      gfn_name: ost$name,
      local_status: ost$status,
      p_attached_pf_entry: pft$p_attached_pf_entry,
      p_catalog_path: ^pft$path,
      p_file_server_buffers: ^pft$file_server_buffers,
      p_input_parameters: ^pft$relink_server_file_inp,
      p_output_parameters: ^pft$relink_server_file_outp,
      path_string: ost$string;

    status.normal := TRUE;
    send_parameters_length := 0;
    data_size_to_send_to_client := 0;

    NEXT p_input_parameters IN p_param_received_from_client;
    pfp$lock_apfid (p_input_parameters^.attached_pf_table_index, p_attached_pf_entry, status);
    IF NOT status.normal THEN
      RETURN {----->
    IFEND;

    IF status.normal AND (p_input_parameters^.global_file_name <>
          p_attached_pf_entry^.internal_cycle_path.cycle_name) THEN
      { What does this mean?  Cant happen?
      pmp$convert_binary_unique_name (p_input_parameters^.global_file_name, gfn_name, status);
      STRINGREP (error_string, error_string_length, 'Mismatch in gfn - Client:', gfn_name, ' Server:');
      pmp$convert_binary_unique_name (p_attached_pf_entry^.internal_cycle_path.cycle_name, gfn_name, status);
      error_string (error_string_length + 1, * ) := gfn_name;
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$invalid_apfid, error_string, status);
    IFEND;

    IF status.normal AND (p_attached_pf_entry^.sfid_status.recovery_state <> pfc$attached_pf_awaiting_client)
          THEN
      { What does this mean?  Cant happen?
      osp$set_status_abnormal (pfc$permanent_file_manager_id, pfe$pf_system_error,
            ' Unexpected recovery state in relink', status);
    IFEND;

    IF status.normal THEN
      file_server_buffers.p_send_parameters := p_send_to_client_params;
      file_server_buffers.p_send_data := p_data_to_client;
      p_file_server_buffers := ^file_server_buffers;
      NEXT p_output_parameters IN file_server_buffers.p_send_parameters;
      IF p_attached_pf_entry^.device_class = rmc$mass_storage_device THEN
        dmp$fetch_server_sft_info (p_attached_pf_entry^.sfid_status.sfid, p_output_parameters^.dm_parameters,
              p_file_server_buffers, status);
      IFEND;
    IFEND;

    IF status.normal THEN
      { Advance the state of the attached permanent file table.
      p_attached_pf_entry^.sfid_status.recovery_state := pfc$attached_pf_normal;
      p_output_parameters^.usage_selections := p_attached_pf_entry^.usage_selections;
      p_output_parameters^.share_selections := p_attached_pf_entry^.share_selections;
      send_parameters_length := i#current_sequence_position (file_server_buffers.p_send_parameters);
      data_size_to_send_to_client := i#current_sequence_position (file_server_buffers.p_send_data);
    ELSE { Unexpected abnormal status - log the fact for debugging
      { The attached permanent file table entry will be released at the end of job recovery.
      p_catalog_path := p_attached_pf_entry^.p_external_path;
      pfp$convert_cycle_path_to_strng (p_catalog_path^, p_attached_pf_entry^.cycle_number, path_string);
      osp$log_job_recovery_message (path_string.value (1, path_string.size), local_status);
      osp$log_job_recovery_status (status, local_status);
    IFEND;
    pfp$unlock_apfid (p_input_parameters^.attached_pf_table_index, p_attached_pf_entry, local_status);
    pfp$process_unexpected_status (local_status);

  PROCEND pfp$relink_file_to_client;

?? TITLE := '  convert_path_to_complete_path', EJECT ??

{ This routine converts a path to a complete path.  The
{ path is assumed to be capitalized already, and name
{ defaulting completed already.  The complete path is
{ assumed to be of length UPPERBOUND(path) + 1.

  PROCEDURE convert_path_to_complete_path
    (    path: pft$path;
     VAR complete_path: pft$complete_path;
     VAR status: ost$status);

    VAR
      path_index: pft$array_index;

    osp$get_set_name (path [pfc$family_name_index], complete_path [pfc$set_path_index], status);

    IF status.normal THEN
      FOR path_index := 1 TO UPPERBOUND (path) DO
        complete_path [path_index + 1] := path [path_index];
      FOREND;
    IFEND;
  PROCEND convert_path_to_complete_path;

?? OLDTITLE, SKIP := 2 ??
MODEND pfm$r2_df_server_requests;
