?? NEWTITLE := 'NOS/VE FILE_TRANSFER : PTF QTF procedures' ??
?? RIGHT := 110 ??
MODULE nfm$rhf_ptf_qtf_procedures;

{     PURPOSE:
{            This module contains procedures which are used by PTF, PTFS,
{            QTF, and QTFS.  These procedures are not common to BTF.
{
{     DESIGN:
{            These modules may be independent of each other, they are
{            application specific in nature.

?? NEWTITLE := 'Global Declarations Referenced By This Module', ??
?? PUSH (LISTEXT := ON) ??
*copyc amt$file_length
*copyc nfe$batch_transfer_services
*copyc nft$control_block
*copyc nft$transfer_modes
?? POP ??
*copyc jmp$emit_communication_stat
*copyc nfp$format_message_to_job_log
*copyc nfp$receive_file
*copyc nfp$send_file
*copyc nfp$set_abnormal_if_normal
*copyc nfp$terminate_path
*copyc osp$set_status_abnormal
*copyc pmp$compute_time_dif_in_seconds
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nfp$generate_ptf_statistic', EJECT ??
*copyc nfh$generate_ptf_statistic

  PROCEDURE [XDCL] nfp$generate_ptf_statistic
    (    begin_connect_time: ost$date_time;
         end_connect_time: ost$date_time;
         file_size: amt$file_length,
         transfer_directives_length: ost$non_negative_integers;
         local_mainframe_system_name: string ( * <= nfc$p27_max_param_size);
         remote_mainframe_system_name: string ( * <= nfc$p25_max_param_size);
         application: nft$application_values;
         ptf_command: ost$string);

?? EJECT ??

    VAR
      connect_time_in_seconds: integer,
      local_status: ost$status,
      ptf_statistic: jmt$ptf_statistic_data,
      statistic_data: jmt$comm_acct_statistic_data;

    pmp$compute_time_dif_in_seconds (begin_connect_time, end_connect_time, connect_time_in_seconds,
          local_status);
    IF NOT local_status.normal THEN
      RETURN;
    IFEND;

    CASE application OF
    = nfc$application_ptf =
      statistic_data.statistic_id := jmc$ca_request_pf_transfer;
      statistic_data.request_perm_file_transfer := ^ptf_statistic;
      ptf_statistic.requesting_mainframe_name := local_mainframe_system_name;
      ptf_statistic.target_mainframe_name := remote_mainframe_system_name;

    = nfc$application_ptfs =
      statistic_data.statistic_id := jmc$ca_target_pf_transfer;
      statistic_data.target_perm_file_transfer := ^ptf_statistic;
      ptf_statistic.requesting_mainframe_name := remote_mainframe_system_name;
      ptf_statistic.target_mainframe_name := local_mainframe_system_name;

    ELSE
      osp$set_status_abnormal (nfc$status_id, nfe$bts_internal_error,
            'Case error in nfp$generate_ptf_statistic', local_status);
      nfp$format_message_to_job_log (local_status);
      RETURN;
    CASEND;

    ptf_statistic.connect_time := connect_time_in_seconds;
    ptf_statistic.file_size := file_size;
    ptf_statistic.bytes_transferred := transfer_directives_length;
    ptf_statistic.command_string := ptf_command;

    jmp$emit_communication_stat (statistic_data);

  PROCEND nfp$generate_ptf_statistic;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nfp$transfer_file', EJECT ??
*copyc nfh$transfer_file

  PROCEDURE [XDCL] nfp$transfer_file
    (VAR control_block: nft$control_block;
     VAR status: ost$status);

    VAR
      local_status: ost$status,
      protocol_consistent: boolean,
      state_of_transfer: ost$status,
      transfer_mode: nft$transfer_modes;

    status.normal := TRUE;

    CASE control_block.data_declaration OF
    = nfc$p31_host_dependent_uh =
      transfer_mode := nfc$ve_to_ve_mode;
    = nfc$p31_unspecified, nfc$p31_ascii_c6, nfc$p31_ascii_c8 =
      transfer_mode := nfc$coded_data_mode;
    = nfc$p31_undefined_structured_us =
      transfer_mode := nfc$rhf_structured_mode;
    = nfc$p31_undef_unstructured_uu =
      transfer_mode := nfc$transparent_data_mode;
    ELSE
      osp$set_status_abnormal (nfc$status_id, nfe$bts_internal_error, 'nfp$transfer_file data type case',
            status);
      RETURN;
    CASEND;

    CASE control_block.application OF

    = nfc$application_ptf =

      CASE control_block.mode_of_access OF
      = nfc$give =
        nfp$receive_file (control_block.path.network_file_id, control_block.file_name,
              control_block.transfer_facilities, transfer_mode, control_block.data_block_size,
              control_block.time_out, control_block.protocol_in_use, control_block.path.network_type,
              control_block.remote_ring.value, control_block.protocol_trace,
              control_block.transfer_file_size, protocol_consistent, state_of_transfer, status);
      = nfc$take =
        nfp$send_file (control_block.path.network_file_id, control_block.file_name,
              control_block.transfer_facilities, transfer_mode, control_block.data_block_size,
              control_block.time_out, control_block.protocol_in_use, control_block.path.network_type,
              control_block.remote_ring.value, control_block.protocol_trace,
              control_block.transfer_file_size, protocol_consistent, state_of_transfer, status);
      ELSE
        osp$set_status_abnormal (nfc$status_id, nfe$bts_internal_error,
              'nfp$transfer_file client mode of access', status);
        RETURN;
      CASEND;

    = nfc$application_ptfs =

      CASE control_block.mode_of_access OF
      = nfc$give =
        nfp$send_file (control_block.path.network_file_id, control_block.file_name,
              control_block.transfer_facilities, transfer_mode, control_block.data_block_size,
              control_block.time_out, control_block.protocol_in_use, control_block.path.network_type,
              control_block.remote_ring.value, control_block.protocol_trace,
              control_block.transfer_file_size, protocol_consistent, state_of_transfer, status);
      = nfc$take =
        nfp$receive_file (control_block.path.network_file_id, control_block.file_name,
              control_block.transfer_facilities, transfer_mode, control_block.data_block_size,
              control_block.time_out, control_block.protocol_in_use, control_block.path.network_type,
              control_block.remote_ring.value, control_block.protocol_trace,
              control_block.transfer_file_size, protocol_consistent, state_of_transfer, status);
      ELSE
        osp$set_status_abnormal (nfc$status_id, nfe$bts_internal_error,
              'nfp$transfer_file server mode of access', status);
        RETURN;
      CASEND;

    ELSE
      osp$set_status_abnormal (nfc$status_id, nfe$bts_internal_error, 'nfp$transfer_file application case',
            status);
      RETURN;
    CASEND;

    IF NOT protocol_consistent THEN
      nfp$terminate_path (control_block.application, TRUE, control_block.path, local_status);
    IFEND;

    IF NOT status.normal THEN
      nfp$set_abnormal_if_normal (status, control_block.local_status);
    IFEND;
    IF (control_block.state_of_transfer.normal) AND (protocol_consistent) THEN
      control_block.state_of_transfer := state_of_transfer;
    IFEND;
{
  PROCEND nfp$transfer_file;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] nfp$count_directives_text', EJECT ??
*copyc nfh$count_directives_text

  FUNCTION [XDCL] nfp$count_directives_text
    (    directives_list_p: ^nft$directive_entry): ost$non_negative_integers;

    VAR
      current_directive_p: ^nft$directive_entry,
      text_count: ost$non_negative_integers;

    text_count := 0;
    current_directive_p := directives_list_p;
    WHILE (current_directive_p <> NIL) DO
      text_count := text_count + STRLENGTH (current_directive_p^.line);
      current_directive_p := current_directive_p^.link;
    WHILEND;
    nfp$count_directives_text := text_count;

  FUNCEND nfp$count_directives_text;
?? OLDTITLE ??
MODEND nfm$rhf_ptf_qtf_procedures;
