?? NEWTITLE := 'NOS/VE Set Management ' ??
MODULE stm$create_set;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the user interface to create a set.
{
{ DESIGN:
{   This module lives in 23d.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ose$heap_full_exceptions
*copyc ste$error_condition_codes
*copyc ost$status
*copyc ost$user_identification
*copyc rmt$recorded_vsn
?? POP ??
*copyc clp$validate_name
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc pmp$exit
*copyc stp$clear_exclusive_access
*copyc stp$dm_mount_volume
*copyc stp$request_dm_volume_info
*copyc stp$ring2_create_set
*copyc stp$search_ast_by_set
*copyc stp$set_exclusive_access
*copyc stp$valid_access_status
*copyc stp$validate_owner
*copyc stp$validate_recorded_vsn
?? OLDTITLE ??
?? NEWTITLE := '   [XDCL, #GATE] stp$create_set ', EJECT ??
*copyc sth$create_set

  PROCEDURE [XDCL, #GATE] stp$create_set
    (    requested_set: stt$set_name;
         requested_master_vol: rmt$recorded_vsn;
         requested_set_owner: ost$user_identification;
         access_status: stt$access_status;
         root_recreated: boolean;
     VAR status: ost$status);

    VAR
      active_volume_table_index: dmt$active_volume_table_index,
      ast_entry: stt$active_set_entry,
      ast_index: stt$ast_index,
      caps_requested_master_vol: rmt$recorded_vsn,
      caps_requested_set: stt$set_name,
      caps_requested_set_owner: ost$user_identification,
      create_set_status: ost$status,
      internal_vsn: dmt$internal_vsn,
      master_vol_found: boolean,
      master_vol_owner: ost$user_identification,
      set_found: boolean;

    create_set_status.normal := TRUE;
    validate_create_set_param (requested_set, requested_master_vol, requested_set_owner, access_status,
          caps_requested_set, caps_requested_master_vol, caps_requested_set_owner, create_set_status);
    IF create_set_status.normal THEN
{
{     DETERMINE IF THE MASTER VOLUME IS ACTIVE                               }
{
      stp$set_exclusive_access;
      stp$search_ast_by_set (caps_requested_set, ast_entry, ast_index, set_found);
      IF set_found THEN
        osp$set_status_abnormal (stc$set_management_id, ste$set_already_active, caps_requested_set,
              create_set_status);
      ELSE
        stp$get_volume_active (caps_requested_master_vol, internal_vsn, master_vol_owner,
              active_volume_table_index, master_vol_found);
      IFEND;
      IF create_set_status.normal THEN
        IF master_vol_found THEN
          stp$validate_master_owner (caps_requested_set_owner, caps_requested_set, master_vol_owner,
                caps_requested_master_vol, create_set_status);
          IF create_set_status.normal THEN
            stp$ring2_create_set (caps_requested_set, caps_requested_master_vol, internal_vsn,
                  caps_requested_set_owner, access_status, active_volume_table_index, root_recreated,
                  create_set_status);
          IFEND;
        ELSE
          osp$set_status_abnormal (stc$set_management_id, ste$master_not_active, caps_requested_master_vol,
                create_set_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, caps_requested_set, create_set_status);
        IFEND;
      IFEND;
      stp$clear_exclusive_access;
    IFEND;
    status := create_set_status;
    IF (NOT status.normal) AND (status.condition = ose$mainframe_pageable_full) THEN
      pmp$exit (status);
    IFEND;

  PROCEND stp$create_set;
?? OLDTITLE ??
?? NEWTITLE := '  stp$get_volume_active ', EJECT ??

  PROCEDURE stp$get_volume_active
    (    volume: rmt$recorded_vsn;
     VAR internal_vsn: dmt$internal_vsn;
     VAR volume_owner: ost$user_identification;
     VAR active_volume_table_index: dmt$active_volume_table_index;
     VAR volume_found: boolean);

{  PURPOSE:
{    The purpose of this routine is determine if a volume is active, and to attempt
{    to mount the volume if it is not.

    VAR
      status: ost$status;

    stp$request_dm_volume_info (volume, internal_vsn, volume_owner, active_volume_table_index, volume_found);
    IF NOT volume_found THEN
      stp$clear_exclusive_access;
      stp$dm_mount_volume (volume, status);
      volume_found := status.normal;
      stp$set_exclusive_access;
      IF volume_found THEN
        stp$request_dm_volume_info (volume, internal_vsn, volume_owner, active_volume_table_index,
              volume_found);
      IFEND;
    IFEND;

  PROCEND stp$get_volume_active;
?? OLDTITLE ??
?? NEWTITLE := '  stp$validate_master_owner ', EJECT ??

  PROCEDURE stp$validate_master_owner
    (    requested_set_owner: ost$user_identification;
         requested_set_name: stt$set_name;
         master_vol_owner: ost$user_identification;
         master_vol_vsn: rmt$recorded_vsn;
     VAR status: ost$status);

    VAR
      valid_owner: boolean;

    stp$validate_owner (requested_set_owner, valid_owner);
    IF valid_owner THEN
      IF master_vol_owner = requested_set_owner THEN
        status.normal := TRUE;
      ELSE
        osp$set_status_abnormal (stc$set_management_id, ste$set_not_master_owner, requested_set_owner.user,
              status);
        osp$append_status_parameter (osc$status_parameter_delimiter, requested_set_owner.family, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, master_vol_vsn, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, requested_set_name, status);
      IFEND;
    ELSE
      osp$set_status_abnormal (stc$set_management_id, ste$set_not_job_owner, requested_set_owner.user,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, requested_set_owner.family, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, requested_set_name, status);
    IFEND;

  PROCEND stp$validate_master_owner;
?? OLDTITLE ??
?? NEWTITLE := '  validate_create_set_param', EJECT ??

  PROCEDURE validate_create_set_param
    (    requested_set: stt$set_name;
         requested_master_vol: rmt$recorded_vsn;
         requested_set_owner: ost$user_identification;
         access_status: stt$access_status;
     VAR cap_requested_set: stt$set_name;
     VAR cap_requested_master_vol: rmt$recorded_vsn;
     VAR cap_requested_set_owner: ost$user_identification;
     VAR parameter_status: ost$status);

{    PURPOSE:
{      This procedure determines if all of the create set parameters are
{      valid.

    VAR
      local_name: ost$name,
      valid_name: boolean,
      valid_owner_name: boolean;

    clp$validate_name (requested_set, local_name, valid_name);
    IF valid_name THEN
      cap_requested_set := local_name;
      stp$validate_recorded_vsn (requested_master_vol, cap_requested_master_vol, parameter_status);
      IF parameter_status.normal THEN
        clp$validate_name (requested_set_owner.family, local_name, valid_owner_name);
        IF valid_owner_name THEN
          cap_requested_set_owner.family := local_name;
          clp$validate_name (requested_set_owner.user, local_name, valid_owner_name);
          IF valid_owner_name THEN
            cap_requested_set_owner.user := local_name;
          IFEND;
        IFEND;
        IF valid_owner_name THEN
          IF stp$valid_access_status (access_status) THEN
            parameter_status.normal := TRUE;
          ELSE
            osp$set_status_abnormal (stc$set_management_id, ste$bad_access_status, stc$null_parameter,
                  parameter_status);
          IFEND;
        ELSE
          osp$set_status_abnormal (stc$set_management_id, ste$bad_set_owner, requested_set_owner.user,
                parameter_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, requested_set_owner.family,
                parameter_status);
        IFEND;
      ELSE
        osp$set_status_abnormal (stc$set_management_id, ste$bad_master_vol_desc, cap_requested_master_vol,
              parameter_status);
      IFEND;
    ELSE
      osp$set_status_abnormal (stc$set_management_id, ste$bad_set_name, requested_set, parameter_status);
    IFEND;

  PROCEND validate_create_set_param;
?? OLDTITLE ??
MODEND stm$create_set;
