?? RIGHT := 110 ??
*copyc osd$default_pragmats
?? NEWTITLE := ' NOS/VE File Server: Manage_File_Server Utility', EJECT ??
MODULE dfm$file_server_management;
{
{  This module accepts the operator commands and does the preliminary
{  command verification. It then calls the next level procedure for farther
{  verification of each command and for the command execution.
{
?? NEWTITLE := '    Global Declarations ', EJECT ??
?? PUSH (LISTEXT := ON) ??

*copyc amp$fetch
*copyc amp$put_next
*copyc amt$file_identifier
*copyc amt$local_file_name
*copyc amt$page_width
*copyc clp$end_scan_command_file
*copyc clp$get_value
*copyc clp$pop_utility
*copyc clp$push_utility
*copyc clp$scan_command_file
*copyc clp$scan_parameter_list
*copyc clt$command_table
*copyc clt$function_table
*copyc dfe$error_condition_codes
*copyc dfi$display
*copyc dfp$activate_client
*copyc dfp$activate_server
*copyc dfp$client_mainframes_display
*copyc dfp$crack_mainframe_id
*copyc dfp$deactivate_client
*copyc dfp$deactivate_server
*copyc dfp$delete_client
*copyc dfp$delete_server
*copyc dfp$display_client
*copyc dfp$display_server
*copyc dfp$display_stornet_connection
*copyc dfp$terminate_client
*copyc dfp$terminate_server
*copyc dfp$timeout_client
*copyc dfp$timeout_server
*copyc dfp$verify_system_administrator
*copyc fsp$close_file
*copyc fsp$open_file
*copyc oss$job_paged_literal
*copyc pmt$binary_mainframe_id
*copyc pmt$mainframe_id

?? POP ??


{ table fs_manager_commands type=command sn=oss$job_paged_literal version=0
{ command (activate_client, actc) activate_client local
{ command (activate_server, acts) activate_server local
{ command (change_client_access, chaca) dfp$change_client_access_cmnd xref
{ command (deactivate_client, deac) deactivate_client local
{ command (deactivate_server, deas) deactivate_server local
{ command (define_application_rpc, defarpc, defar)           dfp$define_application_rpc_cmnd xref
{ command (define_client,defc) dfp$define_client_command xref
{ command (define_client_application_info, defcai)           dfp$define_client_app_info_cmnd xref
{ command (define_served_families, define_served_family, defsf)           ..
{   dfp$define_served_families_cmnd xref
{ command (define_server, defs) dfp$define_server_command xref
{ command (define_stornet_connection,defsc) dfp$define_esm_command xref
{ command (delete_application_rpc, delarpc, delar)           dfp$delete_application_rpc_cmnd xref
{ command (delete_client, delc) delete_client local
{ command (delete_client_application_info delcai)           dfp$delete_client_app_info_cmnd xref
{ command (delete_server, dels) delete_server local
{ command (delete_stornet_connection,delsc) dfp$delete_esm_command xref
{ command (dftu) processor=dfp$driver_test_utility call_method=xref           ..
{   availability=hidden log=automatic
{ command (display_application_rpc, disar) dfp$display_application_rpc xref
{ command (display_client, disc) display_client local
{ command (display_client_access, disca) dfp$display_client_access_cmnd xref
{ command (display_client_application_info, discai)       dfp$display_client_app_info_cmn xref
{ command (display_client_mainframe, display_client_mainframes, discm) ..
{   display_client_mainframes local
{ command (display_server, diss) display_server local
{ command (display_stornet_connection, dissc) display_stornet_connection           local
{ command (terminate_client, terc) terminate_client local
{ command (terminate_server, ters) terminate_server local
{ command (timeout_client, timc) timeout_client local
{ command (timeout_server, tims) timeout_server local
{ command (quit, qui) quit_command local
{ tablend

?? PUSH (LISTEXT := ON) ??

VAR
  fs_manager_commands: [STATIC, READ, oss$job_paged_literal] ^clt$command_table :=
      ^fs_manager_commands_entries,

  fs_manager_commands_entries: [STATIC, READ, oss$job_paged_literal] array [1 .. 61] of
      clt$command_table_entry := [
  {} ['ACTC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^activate_client],
  {} ['ACTIVATE_CLIENT                ', clc$nominal_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^activate_client],
  {} ['ACTIVATE_SERVER                ', clc$nominal_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^activate_server],
  {} ['ACTS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^activate_server],
  {} ['CHACA                          ', clc$abbreviation_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^dfp$change_client_access_cmnd],
  {} ['CHANGE_CLIENT_ACCESS           ', clc$nominal_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^dfp$change_client_access_cmnd],
  {} ['DEAC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^deactivate_client],
  {} ['DEACTIVATE_CLIENT              ', clc$nominal_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^deactivate_client],
  {} ['DEACTIVATE_SERVER              ', clc$nominal_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^deactivate_server],
  {} ['DEAS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^deactivate_server],
  {} ['DEFAR                          ', clc$abbreviation_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^dfp$define_application_rpc_cmnd],
  {} ['DEFARPC                        ', clc$alias_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^dfp$define_application_rpc_cmnd],
  {} ['DEFC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 7,
        clc$automatically_log, clc$linked_call, ^dfp$define_client_command],
  {} ['DEFCAI                         ', clc$abbreviation_entry, clc$normal_usage_entry, 8,
        clc$automatically_log, clc$linked_call, ^dfp$define_client_app_info_cmnd],
  {} ['DEFINE_APPLICATION_RPC         ', clc$nominal_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^dfp$define_application_rpc_cmnd],
  {} ['DEFINE_CLIENT                  ', clc$nominal_entry, clc$normal_usage_entry, 7,
        clc$automatically_log, clc$linked_call, ^dfp$define_client_command],
  {} ['DEFINE_CLIENT_APPLICATION_INFO ', clc$nominal_entry, clc$normal_usage_entry, 8,
        clc$automatically_log, clc$linked_call, ^dfp$define_client_app_info_cmnd],
  {} ['DEFINE_SERVED_FAMILIES         ', clc$nominal_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^dfp$define_served_families_cmnd],
  {} ['DEFINE_SERVED_FAMILY           ', clc$alias_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^dfp$define_served_families_cmnd],
  {} ['DEFINE_SERVER                  ', clc$nominal_entry, clc$normal_usage_entry, 10,
        clc$automatically_log, clc$linked_call, ^dfp$define_server_command],
  {} ['DEFINE_STORNET_CONNECTION      ', clc$nominal_entry, clc$normal_usage_entry, 11,
        clc$automatically_log, clc$linked_call, ^dfp$define_esm_command],
  {} ['DEFS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 10,
         clc$automatically_log, clc$linked_call, ^dfp$define_server_command],
  {} ['DEFSC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 11,
         clc$automatically_log, clc$linked_call, ^dfp$define_esm_command],
  {} ['DEFSF                          ', clc$abbreviation_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^dfp$define_served_families_cmnd],
  {} ['DELAR                          ', clc$abbreviation_entry, clc$normal_usage_entry, 12,
         clc$automatically_log, clc$linked_call, ^dfp$delete_application_rpc_cmnd],
  {} ['DELARPC                        ', clc$alias_entry, clc$normal_usage_entry, 12,
        clc$automatically_log, clc$linked_call, ^dfp$delete_application_rpc_cmnd],
  {} ['DELC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 13,
         clc$automatically_log, clc$linked_call, ^delete_client],
  {} ['DELCAI                         ', clc$abbreviation_entry, clc$normal_usage_entry, 14,
         clc$automatically_log, clc$linked_call, ^dfp$delete_client_app_info_cmnd],
  {} ['DELETE_APPLICATION_RPC         ', clc$nominal_entry, clc$normal_usage_entry, 12,
        clc$automatically_log, clc$linked_call, ^dfp$delete_application_rpc_cmnd],
  {} ['DELETE_CLIENT                  ', clc$nominal_entry, clc$normal_usage_entry, 13,
        clc$automatically_log, clc$linked_call, ^delete_client],
  {} ['DELETE_CLIENT_APPLICATION_INFO ', clc$nominal_entry, clc$normal_usage_entry, 14,
        clc$automatically_log, clc$linked_call, ^dfp$delete_client_app_info_cmnd],
  {} ['DELETE_SERVER                  ', clc$nominal_entry, clc$normal_usage_entry, 15,
        clc$automatically_log, clc$linked_call, ^delete_server],
  {} ['DELETE_STORNET_CONNECTION      ', clc$nominal_entry, clc$normal_usage_entry, 16,
        clc$automatically_log, clc$linked_call, ^dfp$delete_esm_command],
  {} ['DELS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 15,
         clc$automatically_log, clc$linked_call, ^delete_server],
  {} ['DELSC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 16,
         clc$automatically_log, clc$linked_call, ^dfp$delete_esm_command],
  {} ['DFTU                           ', clc$nominal_entry, clc$hidden_entry, 17,
        clc$automatically_log, clc$linked_call, ^dfp$driver_test_utility],
  {} ['DISAR                          ', clc$abbreviation_entry, clc$normal_usage_entry, 18,
         clc$automatically_log, clc$linked_call, ^dfp$display_application_rpc],
  {} ['DISC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 19,
         clc$automatically_log, clc$linked_call, ^display_client],
  {} ['DISCA                          ', clc$abbreviation_entry, clc$normal_usage_entry, 20,
         clc$automatically_log, clc$linked_call, ^dfp$display_client_access_cmnd],
  {} ['DISCAI                         ', clc$abbreviation_entry, clc$normal_usage_entry, 21,
         clc$automatically_log, clc$linked_call, ^dfp$display_client_app_info_cmn],
  {} ['DISCM                          ', clc$abbreviation_entry, clc$normal_usage_entry, 22,
         clc$automatically_log, clc$linked_call, ^display_client_mainframes],
  {} ['DISPLAY_APPLICATION_RPC        ', clc$nominal_entry, clc$normal_usage_entry, 18,
        clc$automatically_log, clc$linked_call, ^dfp$display_application_rpc],
  {} ['DISPLAY_CLIENT                 ', clc$nominal_entry, clc$normal_usage_entry, 19,
        clc$automatically_log, clc$linked_call, ^display_client],
  {} ['DISPLAY_CLIENT_ACCESS          ', clc$nominal_entry, clc$normal_usage_entry, 20,
        clc$automatically_log, clc$linked_call, ^dfp$display_client_access_cmnd],
  {} ['DISPLAY_CLIENT_APPLICATION_INFO', clc$nominal_entry, clc$normal_usage_entry, 21,
        clc$automatically_log, clc$linked_call, ^dfp$display_client_app_info_cmn],
  {} ['DISPLAY_CLIENT_MAINFRAME       ', clc$nominal_entry, clc$normal_usage_entry, 22,
        clc$automatically_log, clc$linked_call, ^display_client_mainframes],
  {} ['DISPLAY_CLIENT_MAINFRAMES      ', clc$alias_entry, clc$normal_usage_entry, 22,
        clc$automatically_log, clc$linked_call, ^display_client_mainframes],
  {} ['DISPLAY_SERVER                 ', clc$nominal_entry, clc$normal_usage_entry, 23,
        clc$automatically_log, clc$linked_call, ^display_server],
  {} ['DISPLAY_STORNET_CONNECTION     ', clc$nominal_entry, clc$normal_usage_entry, 24,
        clc$automatically_log, clc$linked_call, ^display_stornet_connection],
  {} ['DISS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 23,
         clc$automatically_log, clc$linked_call, ^display_server],
  {} ['DISSC                          ', clc$abbreviation_entry, clc$normal_usage_entry, 24,
         clc$automatically_log, clc$linked_call, ^display_stornet_connection],
  {} ['QUI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 29,
         clc$automatically_log, clc$linked_call, ^quit_command],
  {} ['QUIT                           ', clc$nominal_entry, clc$normal_usage_entry, 29,
        clc$automatically_log, clc$linked_call, ^quit_command],
  {} ['TERC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 25,
         clc$automatically_log, clc$linked_call, ^terminate_client],
  {} ['TERMINATE_CLIENT               ', clc$nominal_entry, clc$normal_usage_entry, 25,
        clc$automatically_log, clc$linked_call, ^terminate_client],
  {} ['TERMINATE_SERVER               ', clc$nominal_entry, clc$normal_usage_entry, 26,
        clc$automatically_log, clc$linked_call, ^terminate_server],
  {} ['TERS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 26,
         clc$automatically_log, clc$linked_call, ^terminate_server],
  {} ['TIMC                           ', clc$abbreviation_entry, clc$normal_usage_entry, 27,
         clc$automatically_log, clc$linked_call, ^timeout_client],
  {} ['TIMEOUT_CLIENT                 ', clc$nominal_entry, clc$normal_usage_entry, 27,
        clc$automatically_log, clc$linked_call, ^timeout_client],
  {} ['TIMEOUT_SERVER                 ', clc$nominal_entry, clc$normal_usage_entry, 28,
        clc$automatically_log, clc$linked_call, ^timeout_server],
  {} ['TIMS                           ', clc$abbreviation_entry, clc$normal_usage_entry, 28,
         clc$automatically_log, clc$linked_call, ^timeout_server]];

  PROCEDURE [XREF] dfp$change_client_access_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$define_application_rpc_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$define_client_app_info_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$define_client_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$define_esm_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$define_served_families_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$define_server_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$delete_application_rpc_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$delete_client_app_info_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$delete_esm_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$display_application_rpc
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$display_client_access_cmnd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$display_client_app_info_cmn
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$driver_test_utility
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? POP ??



{ table manfs_functions t=f sn=oss$job_paged_literal v=0
{ function ($client_family_access, $cfa)  dfp$$client_family_access xref a=h
{ function ($client_state, $cs)  dfp$$client_state   xref a=h
{ function ($served_family_access, $sfa)  dfp$$served_family_access xref a=h
{ function ($server_state, $ss)  dfp$$server_state  xref a=h
{ tablend

?? PUSH (LISTEXT := ON) ??

VAR
  manfs_functions: [STATIC, READ, oss$job_paged_literal] ^clt$function_table := ^manfs_functions_entries,

  manfs_functions_entries: [STATIC, READ, oss$job_paged_literal] array [1 .. 8] of
      clt$function_table_entry := [
  {} ['$CFA                           ', clc$abbreviation_entry, clc$hidden_entry, 1, clc$linked_call,
        ^dfp$$client_family_access],
  {} ['$CLIENT_FAMILY_ACCESS          ', clc$nominal_entry, clc$hidden_entry, 1, clc$linked_call,
        ^dfp$$client_family_access],
  {} ['$CLIENT_STATE                  ', clc$nominal_entry, clc$hidden_entry, 2, clc$linked_call,
        ^dfp$$client_state],
  {} ['$CS                            ', clc$abbreviation_entry, clc$hidden_entry, 2, clc$linked_call,
        ^dfp$$client_state],
  {} ['$SERVED_FAMILY_ACCESS          ', clc$nominal_entry, clc$hidden_entry, 3, clc$linked_call,
        ^dfp$$served_family_access],
  {} ['$SERVER_STATE                  ', clc$nominal_entry, clc$hidden_entry, 4, clc$linked_call,
        ^dfp$$server_state],
  {} ['$SFA                           ', clc$abbreviation_entry, clc$hidden_entry, 3, clc$linked_call,
        ^dfp$$served_family_access],
  {} ['$SS                            ', clc$abbreviation_entry, clc$hidden_entry, 4, clc$linked_call,
        ^dfp$$server_state]];

  PROCEDURE [XREF] dfp$$client_family_access
    (    function_name: clt$name;
         argument_list: string ( * );
     VAR value: clt$value;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$$client_state
    (    function_name: clt$name;
         argument_list: string ( * );
     VAR value: clt$value;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$$served_family_access
    (    function_name: clt$name;
         argument_list: string ( * );
     VAR value: clt$value;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$$server_state
    (    function_name: clt$name;
         argument_list: string ( * );
     VAR value: clt$value;
     VAR status: ost$status);

?? POP ??



  CONST
    utility_name = 'MANAGE_FILE_SERVER             ';

  CONST
    default_page_width = 79,
    minimum_page_width = 50,
    maximum_page_width = 110;

?? TITLE := '   dfp$manage_file_server', EJECT ??

  PROCEDURE [XDCL, #GATE] dfp$manage_file_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    VAR
      command_file: amt$local_file_name,
      local_status: ost$status;

{    pdt manage_file_server_pdt (status)

?? PUSH (LISTEXT := ON) ??

    VAR
      manage_file_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^manage_file_server_pdt_names, ^manage_file_server_pdt_params];

    VAR
      manage_file_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 1] of
            clt$parameter_name_descriptor := [['STATUS', 1]];

    VAR
      manage_file_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 1] of
            clt$parameter_descriptor := [

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

?? POP ??

    clp$scan_parameter_list (parameter_list, manage_file_server_pdt, status);

    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$verify_system_administrator ('MANAGE_FILE_SERVER', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$push_utility (utility_name, clc$global_command_search, fs_manager_commands,
          manfs_functions, status);
    IF status.normal THEN
      command_file := '$COMMAND';
      clp$scan_command_file (command_file, utility_name, 'manfs', status);
      clp$pop_utility (local_status);
    IFEND;

  PROCEND dfp$manage_file_server;

?? TITLE := '   dfp$manage_file_server - ALIAS', EJECT ??

  PROCEDURE [XDCL, #GATE] manfs
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    { Provide a short easy to type alias.
    dfp$manage_file_server (parameter_list, status);

  PROCEND manfs;

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

  PROCEDURE activate_client
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{   pdt activate_client_pdt (
{     mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{     status)

?? PUSH (LISTEXT := ON) ??

  VAR
    activate_client_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^activate_client_pdt_names
      , ^activate_client_pdt_params];

  VAR
    activate_client_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    activate_client_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of clt$parameter_descriptor
      := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, activate_client_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$activate_client (mainframe_name, status);

  PROCEND activate_client;

?? TITLE := '   activate_server', EJECT ??

  PROCEDURE activate_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{    pdt activate_server_pdt (
{      mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{      status)

?? PUSH (LISTEXT := ON) ??

  VAR
    activate_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^activate_server_pdt_names
      , ^activate_server_pdt_params];

  VAR
    activate_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    activate_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of clt$parameter_descriptor
      := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, activate_server_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$activate_server (mainframe_name, status);

  PROCEND activate_server;

?? TITLE := '   deactivate_client', EJECT ??

  PROCEDURE deactivate_client
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{   pdt deactivate_client_pdt (mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{         status)

?? PUSH (LISTEXT := ON) ??

  VAR
    deactivate_client_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [
      ^deactivate_client_pdt_names, ^deactivate_client_pdt_params];

  VAR
    deactivate_client_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    deactivate_client_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
      clt$parameter_descriptor := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, deactivate_client_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$deactivate_client (mainframe_name, status);

  PROCEND deactivate_client;

?? TITLE := '   deactivate_server', EJECT ??

  PROCEDURE deactivate_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{     pdt deactivate_server_pdt (
{       mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{       status)

?? PUSH (LISTEXT := ON) ??

  VAR
    deactivate_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [
      ^deactivate_server_pdt_names, ^deactivate_server_pdt_params];

  VAR
    deactivate_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    deactivate_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
      clt$parameter_descriptor := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, deactivate_server_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$deactivate_server (mainframe_name, status);

  PROCEND deactivate_server;

?? TITLE := '   delete_client', EJECT ??

  PROCEDURE delete_client
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{     pdt delete_client_pdt (
{       mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{       status)

?? PUSH (LISTEXT := ON) ??

  VAR
    delete_client_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^delete_client_pdt_names,
      ^delete_client_pdt_params];

  VAR
    delete_client_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    delete_client_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of clt$parameter_descriptor
      := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, delete_client_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$delete_client (mainframe_name, status);

  PROCEND delete_client;

?? TITLE := '   delete_server', EJECT ??

  PROCEDURE delete_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);


{    pdt delete_server_pdt (
{      mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{      status)

?? PUSH (LISTEXT := ON) ??

  VAR
    delete_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^delete_server_pdt_names,
      ^delete_server_pdt_params];

  VAR
    delete_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    delete_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of clt$parameter_descriptor
      := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, delete_server_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$delete_server (mainframe_name, status);

  PROCEND delete_server;

?? TITLE := '  display_client', EJECT ??

  PROCEDURE display_client
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{    pdt display_client_pdt (
{      mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{      output, o: file = $OUTPUT
{      status)

?? PUSH (LISTEXT := ON) ??

  VAR
    display_client_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^display_client_pdt_names,
      ^display_client_pdt_params];

  VAR
    display_client_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 5] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['OUTPUT', 2], ['O', 2], [
      'STATUS', 3]];

  VAR
    display_client_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor
      := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ OUTPUT O }
    [[clc$optional_with_default, ^display_client_pdt_dv2], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL,
      clc$file_value]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

  VAR
    display_client_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (7) := '$OUTPUT';

?? POP ??

    VAR
      ignore_status: ost$status,
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id,
      output_file_fid: amt$file_identifier,
      output_file_name: amt$local_file_name,
      page_width: amt$page_width,
      value: clt$value;

    clp$scan_parameter_list (parameter_list, display_client_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('OUTPUT', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    output_file_name := value.file.local_file_name;
    open_output_file (output_file_name, output_file_fid, page_width, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$display_client (mainframe_name, output_file_fid, page_width, status);
    IF status.normal THEN
      fsp$close_file (output_file_fid, status);
    ELSE
      fsp$close_file (output_file_fid, ignore_status);
    IFEND;

  PROCEND display_client;

?? TITLE := '  display_client_mainframes ', EJECT ??

  PROCEDURE display_client_mainframes
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ pdt display_client_mfs (
{    output, o: file = $output
{    status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

    VAR
      display_client_mfs: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^display_client_mfs_names , ^display_client_mfs_params];

    VAR
      display_client_mfs_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
            clt$parameter_name_descriptor := [['OUTPUT', 1], ['O', 1], ['STATUS', 2]];

    VAR
      display_client_mfs_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
            clt$parameter_descriptor := [

{ OUTPUT O }
            [[clc$optional_with_default, ^display_client_mfs_dv1], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$file_value]],

{ STATUS }
            [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
            clc$array_not_allowed, clc$status_value]]];

    VAR
      display_client_mfs_dv1: [STATIC, READ, cls$pdt_names_and_defaults] string (7) := '$output';

?? FMT (FORMAT := ON) ??
?? POP ??

    VAR
      file_name: amt$local_file_name,
      name: ost$name,
      value: clt$value;


    status.normal := TRUE;
    clp$scan_parameter_list (parameter_list, display_client_mfs, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('OUTPUT', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$client_mainframes_display (value.file.local_file_name, status);

  PROCEND display_client_mainframes;
?? TITLE := '  display_server', EJECT ??

  PROCEDURE display_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);


{    pdt display_server_pdt (
{      mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{      output, o: file = $OUTPUT
{      status)

?? PUSH (LISTEXT := ON) ??

  VAR
    display_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^display_server_pdt_names,
      ^display_server_pdt_params];

  VAR
    display_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 5] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['OUTPUT', 2], ['O', 2], [
      'STATUS', 3]];

  VAR
    display_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor
      := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ OUTPUT O }
    [[clc$optional_with_default, ^display_server_pdt_dv2], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL,
      clc$file_value]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

  VAR
    display_server_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (7) := '$OUTPUT';

?? POP ??

    VAR
      ignore_status: ost$status,
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id,
      output_file_fid: amt$file_identifier,
      output_file_name: amt$local_file_name,
      page_width: amt$page_width,
      value: clt$value;

    clp$scan_parameter_list (parameter_list, display_server_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('OUTPUT', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    output_file_name := value.file.local_file_name;
    open_output_file (output_file_name, output_file_fid, page_width, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$display_server (mainframe_name, output_file_fid, page_width, status);
    IF status.normal THEN
      fsp$close_file (output_file_fid, status);
    ELSE
      fsp$close_file (output_file_fid, ignore_status);
    IFEND;

  PROCEND display_server;

?? TITLE := '  display_stornet_connection', EJECT ??
  PROCEDURE display_stornet_connection
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{     pdt display_stornet_pdt (
{       element_name, en: name = $required
{       output, o: file = $OUTPUT
{       status)

?? PUSH (LISTEXT := ON) ??

  VAR
    display_stornet_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^display_stornet_pdt_names
      , ^display_stornet_pdt_params];

  VAR
    display_stornet_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 5] of
      clt$parameter_name_descriptor := [['ELEMENT_NAME', 1], ['EN', 1], ['OUTPUT', 2], ['O', 2], ['STATUS', 3]
      ];

  VAR
    display_stornet_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor
      := [

{ ELEMENT_NAME EN }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, 1, osc$max_name_size]],

{ OUTPUT O }
    [[clc$optional_with_default, ^display_stornet_pdt_dv2], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL,
      clc$file_value]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

  VAR
    display_stornet_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (7) := '$OUTPUT';

?? POP ??

    VAR
      element_name: cmt$element_name,
      ignore_status: ost$status,
      output_file_fid: amt$file_identifier,
      output_file_name: amt$local_file_name,
      page_width: amt$page_width,
      value: clt$value;

    clp$scan_parameter_list (parameter_list, display_stornet_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('ELEMENT_NAME', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    element_name := value.name.value;

    clp$get_value ('OUTPUT', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    output_file_name := value.file.local_file_name;
    open_output_file (output_file_name, output_file_fid, page_width, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$display_stornet_connection (element_name, output_file_fid, page_width, status);
    IF status.normal THEN
      fsp$close_file (output_file_fid, status);
    ELSE
      fsp$close_file (output_file_fid, ignore_status);
    IFEND;

  PROCEND display_stornet_connection;

?? TITLE := '  open_output_file', EJECT ??

  PROCEDURE open_output_file
    (    file_name: amt$local_file_name;
     VAR output_file_fid: amt$file_identifier;
     VAR page_width: amt$page_width;
     VAR status: ost$status);

    VAR
      file_attachment: array [1 .. 3] of fst$attachment_option,
      local_status: ost$status,

      output_file_attributes: array [1 .. 1] of amt$fetch_item;

    file_attachment [1].selector := fsc$access_and_share_modes;
    file_attachment [1].access_modes.selector := fsc$specific_access_modes;
    file_attachment [1].access_modes.value := $fst$file_access_options [fsc$append, fsc$shorten];
    file_attachment [1].share_modes.selector := fsc$specific_share_modes;
    file_attachment [1].share_modes.value := $fst$file_access_options [];
    file_attachment [2].selector := fsc$access_and_share_modes;
    file_attachment [2].access_modes.selector := fsc$specific_access_modes;
    file_attachment [2].access_modes.value := $fst$file_access_options [fsc$append];
    file_attachment [2].share_modes.selector := fsc$specific_share_modes;
    file_attachment [2].share_modes.value := $fst$file_access_options [];
    file_attachment [3].selector := fsc$open_share_modes;
    file_attachment [3].open_share_modes := -$fst$file_access_options [];

    fsp$open_file (file_name, amc$record, ^file_attachment, NIL, NIL, NIL, NIL, output_file_fid, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    output_file_attributes [1].key := amc$page_width;
    amp$fetch (output_file_fid, output_file_attributes, status);
    IF NOT status.normal THEN
      fsp$close_file (output_file_fid, local_status);
      RETURN;
    IFEND;

    IF (output_file_attributes [1].source <> amc$undefined_attribute) AND
          (output_file_attributes [1].source <> amc$access_method_default) THEN
      page_width := output_file_attributes [1].page_width;
    ELSE
      page_width := default_page_width;
    IFEND;

    IF page_width < minimum_page_width THEN
      page_width := minimum_page_width;
    ELSEIF page_width > maximum_page_width THEN
      page_width := maximum_page_width;
    IFEND;

  PROCEND open_output_file;

?? TITLE := '   terminate_client', EJECT ??

  PROCEDURE terminate_client
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{     pdt terminate_client_pdt (
{       mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{       status)

?? PUSH (LISTEXT := ON) ??

  VAR
    terminate_client_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [
      ^terminate_client_pdt_names, ^terminate_client_pdt_params];

  VAR
    terminate_client_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    terminate_client_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
      clt$parameter_descriptor := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, terminate_client_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$terminate_client (mainframe_name, status);

  PROCEND terminate_client;

?? TITLE := '   terminate_server', EJECT ??

  PROCEDURE terminate_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ pdt terminate_server_pdt (
{   mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{   users_wait_on_terminated, uwot: boolean
{   status)

?? PUSH (LISTEXT := ON) ??

  VAR
    terminate_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [
  ^terminate_server_pdt_names, ^terminate_server_pdt_params];

  VAR
    terminate_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 5] of
  clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['USERS_WAIT_ON_TERMINATED', 2], [
  'UWOT', 2], ['STATUS', 3]];

  VAR
    terminate_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of
  clt$parameter_descriptor := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
  pmc$mainframe_id_size]],

{ USERS_WAIT_ON_TERMINATED UWOT }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$boolean_value]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
  clc$array_not_allowed, clc$status_value]]];

?? POP ??
    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id,
      users_wait_on_term_specified: boolean,
      users_wait_on_terminated: boolean,
      value: clt$value;

    clp$scan_parameter_list (parameter_list, terminate_server_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('USERS_WAIT_ON_TERMINATED', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF value.kind = clc$unknown_value THEN
      users_wait_on_term_specified := FALSE;
    ELSE
      users_wait_on_term_specified := TRUE;
      users_wait_on_terminated := value.bool.value;
    IFEND;

    dfp$terminate_server (mainframe_name, users_wait_on_term_specified,
          users_wait_on_terminated, status);

  PROCEND terminate_server;
?? TITLE := '   timeout_client', EJECT ??

  PROCEDURE timeout_client
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{     pdt timeout_client_pdt (
{       mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{       status)

?? PUSH (LISTEXT := ON) ??

  VAR
    timeout_client_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [
      ^timeout_client_pdt_names, ^timeout_client_pdt_params];

  VAR
    timeout_client_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    timeout_client_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
      clt$parameter_descriptor := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, timeout_client_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$timeout_client (mainframe_name, status);

  PROCEND timeout_client;
?? TITLE := '   timeout_server', EJECT ??

  PROCEDURE timeout_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{     pdt timeout_server_pdt (
{       mainframe_identifier, mi: name pmc$mainframe_id_size = $required
{       status)

?? PUSH (LISTEXT := ON) ??

  VAR
    timeout_server_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [
      ^timeout_server_pdt_names, ^timeout_server_pdt_params];

  VAR
    timeout_server_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
      clt$parameter_name_descriptor := [['MAINFRAME_IDENTIFIER', 1], ['MI', 1], ['STATUS', 2]];

  VAR
    timeout_server_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
      clt$parameter_descriptor := [

{ MAINFRAME_IDENTIFIER MI }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, pmc$mainframe_id_size,
      pmc$mainframe_id_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_name: pmt$mainframe_id;

    clp$scan_parameter_list (parameter_list, timeout_server_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    dfp$crack_mainframe_id ('MAINFRAME_IDENTIFIER', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$timeout_server (mainframe_name, status);

  PROCEND timeout_server;

?? TITLE := '   QUIT', EJECT ??

  PROCEDURE quit_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{   pdt quit_pdt ()

?? PUSH (LISTEXT := ON) ??

    VAR
      quit_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [NIL, NIL];

?? POP ??

    clp$scan_parameter_list (parameter_list, quit_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$end_scan_command_file (utility_name, status);

  PROCEND quit_command;

MODEND dfm$file_server_management;
