?? RIGHT := 110 ??
?? TITLE := 'NOS/VE Resource Management: Mass Storage Validation' ??
MODULE rmm$validate_mass_storage_info;

{ PURPOSE:
{   This module contains the procedures to perform mass storage request validation.

?? NEWTITLE := '  Global Declarations Referenced by this module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$mainframe_paged_literal
*copyc jmc$system_family
*copyc rme$request_mass_storage
*copyc fmt$mass_storage_request_info
*copyc pft$object_types
*copyc rmt$mass_storage_class
?? POP ??
*copyc avp$get_capability
*copyc avp$system_administrator
*copyc cmp$get_ms_class_on_volume
*copyc fsp$convert_fs_structure_to_pf
*copyc fsp$path_element
*copyc jmp$get_scheduling_admin_status
*copyc jmp$system_job
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pmp$get_job_names
*copyc pmp$get_user_identification
*copyc stp$get_volumes_set_name
?? OLDTITLE ??
?? NEWTITLE := '  Global Declarations Declared by this module' ??

  VAR
    v$site_analyst_ms_classes: [READ, oss$mainframe_paged_literal] dmt$class := $dmt$class ['U', 'V', 'W',
          'X', 'Y', 'Z'];

?? TITLE := '  [XDCL, #GATE] rmp$build_mass_storage_info', EJECT ??
*copy rmh$build_mass_storage_info

  PROCEDURE [XDCL, #GATE] rmp$build_mass_storage_info
    (    allocation_size: rmt$allocation_size;
         estimated_file_size: amt$file_byte_address;
         initial_volume: rmt$recorded_vsn;
         mass_storage_class: rmt$mass_storage_class;
         shared_queue: pft$shared_queue;
         transfer_size: fst$transfer_size;
         volume_overflow_allowed: boolean;
         ring_of_caller: ost$ring;
         p_mass_storage_request_info: {output} ^fmt$mass_storage_request_info;
     VAR status: ost$status);

    VAR
      engineering_operation: boolean,
      job_scheduling_admin_status: ost$status,
      local_status: ost$status,
      user_id: ost$user_identification,
      user_supplied_name: jmt$user_supplied_name,
      system_supplied_name: jmt$system_supplied_name;

    local_status.normal := TRUE;

    p_mass_storage_request_info^.allocation_size := allocation_size;
    p_mass_storage_request_info^.estimated_file_size := estimated_file_size;
    p_mass_storage_request_info^.initial_volume := initial_volume;
    p_mass_storage_request_info^.mass_storage_class := mass_storage_class;
    p_mass_storage_request_info^.shared_queue := shared_queue;
    p_mass_storage_request_info^.transfer_size := transfer_size;
    p_mass_storage_request_info^.volume_overflow_allowed := volume_overflow_allowed;

    pmp$get_user_identification (user_id, local_status);
    IF local_status.normal THEN
      jmp$get_scheduling_admin_status (job_scheduling_admin_status);
      IF avp$system_administrator () OR (ring_of_caller <= osc$tsrv_ring) OR
            job_scheduling_admin_status.normal THEN
        p_mass_storage_request_info^.user_privilege := rmc$system_user;
      ELSEIF ring_of_caller <= osc$sj_ring_3 THEN
        p_mass_storage_request_info^.user_privilege := rmc$privileged_user;
      ELSE
        p_mass_storage_request_info^.user_privilege := rmc$normal_user;
      IFEND;

      avp$get_capability (avc$engineering_operation, avc$user, engineering_operation, local_status);
      IF (NOT local_status.normal) THEN
        local_status.normal := TRUE;
        IF jmp$system_job () THEN
          engineering_operation := TRUE;
        IFEND;
      IFEND;
      p_mass_storage_request_info^.maintenance_job := engineering_operation;
    IFEND;

    IF NOT local_status.normal THEN
      status := local_status;
    IFEND;
  PROCEND rmp$build_mass_storage_info;

?? TITLE := '  [XDCL, #GATE] rmp$validate_mass_storage_info', EJECT ??
*copyc rmh$validate_mass_storage_info

  PROCEDURE [XDCL, #GATE] rmp$validate_mass_storage_info
    (    family_set_name: pft$name;
         object_permanent: boolean;
         object_type: pft$object_types;
         p_mass_storage_request_info: {input} ^fmt$mass_storage_request_info;
     VAR status: ost$status);

    VAR
      dm_valid_class: dmt$class,
      file_class_string: string (1),
      volume_set_name: stt$set_name;

    status.normal := TRUE;

    CASE object_type OF
    = pfc$file_object =
      IF object_permanent THEN
        IF p_mass_storage_request_info^.mass_storage_class <> rmc$unspecified_file_class THEN
          IF (p_mass_storage_request_info^.user_privilege = rmc$normal_user) AND
                (p_mass_storage_request_info^.mass_storage_class <> rmc$msc_user_permanent_files) AND
                (NOT (p_mass_storage_request_info^.mass_storage_class IN v$site_analyst_ms_classes)) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          ELSEIF (p_mass_storage_request_info^.user_privilege = rmc$privileged_user) AND
                ((p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_swap_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_catalogs) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_permanent_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_user_catalogs) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_product_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_critical_files)) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          IFEND;
        IFEND;

        IF p_mass_storage_request_info^.initial_volume <> rmc$unspecified_vsn THEN
          stp$get_volumes_set_name (p_mass_storage_request_info^.initial_volume, volume_set_name, status);
          IF NOT status.normal THEN
            osp$set_status_abnormal (rmc$resource_management_id, rme$vsn_not_part_of_set,
                  p_mass_storage_request_info^.initial_volume, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, family_set_name, status);
            RETURN; {----->
          IFEND;

          IF family_set_name <> volume_set_name THEN
            osp$set_status_abnormal (rmc$resource_management_id, rme$vsn_not_part_of_set,
                  p_mass_storage_request_info^.initial_volume, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, family_set_name, status);
            RETURN; {----->
          IFEND;

          get_volume_valid_classes (p_mass_storage_request_info^.initial_volume, dm_valid_class);

          IF (p_mass_storage_request_info^.user_privilege = rmc$normal_user) AND
                (dm_valid_class * ($dmt$class [rmc$msc_user_permanent_files] + v$site_analyst_ms_classes) =
                $dmt$class []) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          ELSEIF (p_mass_storage_request_info^.user_privilege = rmc$privileged_user) AND
                (dm_valid_class - $dmt$class [rmc$unspecified_file_class, rmc$msc_system_swap_files,
                rmc$msc_system_catalogs, rmc$msc_system_permanent_files, rmc$msc_user_catalogs,
                rmc$msc_product_files, rmc$msc_system_critical_files] = $dmt$class []) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          IFEND;

          IF (p_mass_storage_request_info^.mass_storage_class <> rmc$unspecified_file_class) AND
                NOT (p_mass_storage_request_info^.mass_storage_class IN dm_valid_class) THEN
            file_class_string := p_mass_storage_request_info^.mass_storage_class;
            osp$set_status_abnormal (rmc$resource_management_id, rme$file_class_not_valid,
                  p_mass_storage_request_info^.initial_volume, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, file_class_string, status);
            RETURN; {----->
          IFEND;
        IFEND;

      ELSE { Temporary file
        IF p_mass_storage_request_info^.mass_storage_class <> rmc$unspecified_file_class THEN
          IF (p_mass_storage_request_info^.user_privilege = rmc$normal_user) AND
                (p_mass_storage_request_info^.mass_storage_class <> rmc$msc_user_temporary_files) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          ELSEIF (p_mass_storage_request_info^.user_privilege = rmc$privileged_user) AND
                ((p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_swap_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_catalogs) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_permanent_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_product_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_user_catalogs) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_critical_files)) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          IFEND;
        IFEND;

        IF p_mass_storage_request_info^.initial_volume <> rmc$unspecified_vsn THEN
          stp$get_volumes_set_name (p_mass_storage_request_info^.initial_volume, volume_set_name, status);
          IF NOT status.normal THEN
            osp$set_status_abnormal (rmc$resource_management_id, rme$unknown_volume,
                  p_mass_storage_request_info^.initial_volume, status);
            RETURN; {----->
          IFEND;

          IF NOT p_mass_storage_request_info^.maintenance_job THEN
            get_volume_valid_classes (p_mass_storage_request_info^.initial_volume, dm_valid_class);

            IF (p_mass_storage_request_info^.user_privilege = rmc$normal_user) AND
                  NOT (rmc$msc_user_temporary_files IN dm_valid_class) THEN
              osp$set_status_condition (rme$job_not_valid, status);
              RETURN; {----->
            ELSEIF (p_mass_storage_request_info^.user_privilege = rmc$privileged_user) AND
                  (dm_valid_class - $dmt$class [rmc$unspecified_file_class, rmc$msc_system_swap_files,
                  rmc$msc_system_catalogs, rmc$msc_system_permanent_files, rmc$msc_user_catalogs,
                  rmc$msc_product_files, rmc$msc_system_critical_files] = $dmt$class []) THEN
              osp$set_status_condition (rme$job_not_valid, status);
              RETURN; {----->
            IFEND;
          IFEND;
        IFEND;
      IFEND;

    = pfc$catalog_object =
      IF object_permanent THEN
        IF p_mass_storage_request_info^.mass_storage_class <> rmc$unspecified_file_class THEN
          IF (p_mass_storage_request_info^.user_privilege = rmc$normal_user) AND
                (p_mass_storage_request_info^.mass_storage_class <> rmc$msc_user_catalogs) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          ELSEIF (p_mass_storage_request_info^.user_privilege = rmc$privileged_user) AND
                ((p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_swap_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_catalogs) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_permanent_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_product_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_user_permanent_files) OR
                (p_mass_storage_request_info^.mass_storage_class = rmc$msc_system_critical_files)) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          IFEND;
        IFEND;

        IF p_mass_storage_request_info^.initial_volume <> rmc$unspecified_vsn THEN
          stp$get_volumes_set_name (p_mass_storage_request_info^.initial_volume, volume_set_name, status);
          IF NOT status.normal THEN
            osp$set_status_abnormal (rmc$resource_management_id, rme$vsn_not_part_of_set,
                  p_mass_storage_request_info^.initial_volume, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, family_set_name, status);
            RETURN; {----->
          IFEND;

          IF family_set_name <> volume_set_name THEN
            osp$set_status_abnormal (rmc$resource_management_id, rme$vsn_not_part_of_set,
                  p_mass_storage_request_info^.initial_volume, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, family_set_name, status);
            RETURN; {----->
          IFEND;

          get_volume_valid_classes (p_mass_storage_request_info^.initial_volume, dm_valid_class);

          IF (p_mass_storage_request_info^.user_privilege = rmc$normal_user) AND
                NOT (rmc$msc_user_permanent_files IN dm_valid_class) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          ELSEIF (p_mass_storage_request_info^.user_privilege = rmc$privileged_user) AND
                (dm_valid_class - $dmt$class [rmc$unspecified_file_class, rmc$msc_system_swap_files,
                rmc$msc_system_catalogs, rmc$msc_system_permanent_files, rmc$msc_user_catalogs,
                rmc$msc_product_files, rmc$msc_system_critical_files] = $dmt$class []) THEN
            osp$set_status_condition (rme$job_not_valid, status);
            RETURN; {----->
          IFEND;

          IF p_mass_storage_request_info^.mass_storage_class <> rmc$unspecified_file_class THEN
            IF NOT (p_mass_storage_request_info^.mass_storage_class IN dm_valid_class) THEN
              file_class_string := p_mass_storage_request_info^.mass_storage_class;
              osp$set_status_abnormal (rmc$resource_management_id, rme$file_class_not_valid,
                    p_mass_storage_request_info^.initial_volume, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, file_class_string, status);
              RETURN; {----->
            IFEND;
          IFEND;
        IFEND;
      ELSE { Temporary catalog
      IFEND;
    ELSE
    CASEND;

    IF (NOT p_mass_storage_request_info^.volume_overflow_allowed) AND (object_type <> pfc$catalog_object) AND
          ((p_mass_storage_request_info^.user_privilege <> rmc$system_user) AND
          (NOT p_mass_storage_request_info^.maintenance_job)) THEN
      osp$set_status_abnormal (rmc$resource_management_id, rme$volume_overflow_required, '', status);
    IFEND;
  PROCEND rmp$validate_mass_storage_info;

?? TITLE := '  [INLINE] get_volume_valid_classes', EJECT ??

  PROCEDURE get_volume_valid_classes
    (    recorded_vsn: rmt$recorded_vsn;
     VAR valid_classes: dmt$class);

    VAR
      ms_class: cmt$ms_class_members,
      ms_class_info: cmt$ms_class_info,
      volume_found: boolean;

    valid_classes := $dmt$class [];

    cmp$get_ms_class_on_volume (recorded_vsn, volume_found, ms_class_info);
    IF NOT volume_found THEN
      RETURN; {----->
    IFEND;

    FOR ms_class := LOWERBOUND (ms_class_info.classes) TO UPPERBOUND (ms_class_info.classes) DO
      IF ms_class_info.classes [ms_class] THEN
        valid_classes := valid_classes + $dmt$class [ms_class];
      IFEND;
    FOREND;
  PROCEND get_volume_valid_classes;

MODEND rmm$validate_mass_storage_info;

