AUTHORIZE utility, Access Restrictions

Now that we've documented the utility and defined the UI, let's dive into the code that implements the features. Because the utility directly accesses SYSUAF.DAT, we will use the SYSUAF module that we discussed back in articles 42-44. As you may recall, the executive directly accessed the SYSUAF.DAT file via that module, which uses a File access class that is internal to the executive. Obviously, such class cannot be used in an application program. So, the following code is our implementation of a wrapper for the TUOS_File class used by SYSUAF, which will be used by the code in the following articles.

type TAuth_File_Wrapper = class( TUOS_File )
                             public // API...
                                 _File : TCOM_UOS_File ;

                                 function Create_Stream( Name : int64 ) : longint ;
                                     override ;

                                 // Delete stream...
                                 procedure Delete_Stream( Name : int64 ; Index : longint ) ;
                                     override ;

                                 // Stearm information...
                                 function Max_Stream : longint ;
                                     override ;

                                 function Stream_Name( Index : longint ) : int64 ;
                                     override ;

                                 function Stream_Index( Name : PChar ) : longint ;
                                     override ;

                                 // I/O...
                                 function Read( Stream : longint ;
                                     Position : TStore_Address64 ;
                                     Length : TStore_Size64 ;
                                     var Buff ; Flags : longint ) : TStore_Size64 ;
                                     override ;

                                 function Write( Stream : longint ;
                                     Position : TStore_Address64 ;
                                     Length : TStore_Size64 ; var Buff ;
                                     Flags : longint ) : TStore_Size64 ;
                                     override ;

                                 function Get_Stream_Size( Stream : longint ) : TStore_Size64 ;
                                     override ;

                                 procedure Set_Stream_Size( Stream : longint ;
                                     Value : TStore_Size64 ) ;
                                     override ;

                                 function Get_Contiguous : boolean ;
                                     override ;

                                 procedure Set_Contiguous( Value : boolean ) ;
                                     override ;

                                 function Get_File_Size : int64 ; override ;

                                 procedure Set_File_Size( Value : int64 ) ;
                                     override ;

                                 function Read_Only : boolean ; override ;

                                 function Write_Only : boolean ; override ;

                                 function XSpaceAvail : int64 ; override ;

                                 function Is_Store : boolean ; override ;

                                 function Name : PChar ; override ;

                                 function ID : int64 ; override ;

                                 function Last_Error_Code : int64 ; override ;

                                 function Owner : int64 ; override ;

                                 function ACL : int64 ; override ;

                                 function Flags : int64 ; override ;
                         end ; // TAuth_File_Wrapper


function TAuth_File_Wrapper.Create_Stream( Name : int64 ) : longint ;

begin
    Result := 0 ;
end ;


// Delete stream...
procedure TAuth_File_Wrapper.Delete_Stream( Name : int64 ; Index : longint ) ;

begin
    // Intentionally left blank
end ;


// Stearm information...
function TAuth_File_Wrapper.Max_Stream : longint ;

begin
    Result := 0 ;
end ;



function TAuth_File_Wrapper.Stream_Name( Index : longint ) : int64 ;

begin
    Result := 0 ;
end ;


function TAuth_File_Wrapper.Stream_Index( Name : PChar ) : longint ;

begin
    Result := _File.Stream_Index( Name ) ;
end ;


// I/O...
function TAuth_File_Wrapper.Read( Stream : longint ;
   Position : TStore_Address64 ;
   Length : TStore_Size64 ; var Buff ; Flags : longint ) : TStore_Size64 ;

begin
    Result := _File.Read_Stream( 0, Position, Length, int64( @Buff ) ) ;
end ;


function TAuth_File_Wrapper.Write( Stream : longint ;
   Position : TStore_Address64 ;
   Length : TStore_Size64 ; var Buff ;
   Flags : longint ) : TStore_Size64 ;

var UEC : TUnified_Exception ;

begin
    Result := _File.Write_Data( Buff, Position, Length, UEC )
end ;


function TAuth_File_Wrapper.Get_Stream_Size( Stream : longint ) : TStore_Size64 ;

begin
    Result := _File.Stream_Length( Stream ) ;
end ;


procedure TAuth_File_Wrapper.Set_Stream_Size( Stream : longint ;
   Value : TStore_Size64 ) ;

begin
    _File.Set_Size( Value ) ;
end ;


function TAuth_File_Wrapper.Get_Contiguous : boolean ;

begin
    Result := _File.Contiguous_Store ;
end ;


procedure TAuth_File_Wrapper.Set_Contiguous( Value : boolean ) ;

begin
    // Intentionally left blank
end ;


function TAuth_File_Wrapper.Get_File_Size : int64 ;

begin
    Result := _File.Stream_Length( 0 ) ;
end ;


procedure TAuth_File_Wrapper.Set_File_Size( Value : int64 ) ;

begin
    Set_Stream_Size( 0, Value ) ;
end ;


function TAuth_File_Wrapper.Read_Only : boolean ;

begin
    Result := False ; 
end ;


function TAuth_File_Wrapper.Write_Only : boolean ;

begin
    Result := False ; 
end ;


function TAuth_File_Wrapper.XSpaceAvail : int64 ;

begin
end ;


function TAuth_File_Wrapper.Is_Store : boolean ;

begin
    Result := True ;
end ;


function TAuth_File_Wrapper.Name : PChar ;

begin
    Result := _File.Get_Name ;
end ;


function TAuth_File_Wrapper.ID : int64 ;

begin
    Result := 0 ;
end ;


function TAuth_File_Wrapper.Last_Error_Code : int64 ;

begin
    Result := _File.IO_Error.Get_Error ;
end ;


function TAuth_File_Wrapper.Owner : int64 ;

begin
    Result := 0 ;
end ;


function TAuth_File_Wrapper.ACL : int64 ;

begin
    Result := 0 ;
end ;


function TAuth_File_Wrapper.Flags : int64 ;

begin
    Result := 0 ;
end ;



function Create_UOS_File_Wrapper( F : TCOM_UOS_File ) : TUOS_File ;

begin
    Result := TAuth_File_Wrapper.Create ;
    TAuth_File_Wrapper( Result )._File := F ;
end ;

There isn't much to discuss here - the wrapper methods are straight-forward. TAuth_File_Wrapper translates between a TCOM_UOS_File (used with applications) and a TUOS_File (used in SYSUAF). The Create_UOS_File_Wrapper function simply creates a wrapper for the passed file.

As mentioned before, though the VMS documentation is our specification, there are a finite number of deviations from VMS that were planned for UOS. One of those has to do with account access restrictions. VMS allows access restrictions based on hour intervals. In UOS, the resolution is at minute intervals. For instance, UOS could restrict access for an account from 3:15 PM to 4:45 PM, whereas VMS couldn't. One must understand that the point of access restrictions in UOS is slightly different than in VMS. In UOS, the feature is intended for use by parents in restricting the amount of computer access for children. In VMS it was intended to spread out peak usage on timesharing systems (although it could be used for the same purpose on UOS, if desired). The time value used for UOS access restrictions is the minute of the day. For instance, 0 indicates 12:00 midnight, 1 indicates 12:01 AM, etc.

Now we will examine the support routines for account access day/time specifications. In the next article, we will address the code that uses these routines.

function MinMatch( S, M : string ; Req : integer) : boolean ;

begin
    Result := False ;
    S := trim( lowercase( S ) ) ;
    M := trim( lowercase( M ) ) ;
    if( length( M ) < Req ) then
    begin
        exit ;
    end ;
    Result := copy( S, 1, length( M ) ) = M ;
end ;

This function does an abbreviation match.

// Day/Hour/Minute processing routines...

function Minute_To_Text( M : cardinal ) : string ;

begin
    Result := inttostr( M - ( M div 60 * 60 ) ) ;
    if( length( Result ) = 1 ) then
    begin
        Result := '0' + Result ;
    end ;
    Result := inttostr( M div 60 ) + ':' + Result ;
end ;

This function simply returns a string version of an hour/minute value, making sure that the minute is zero-filled if needed.

function Access_Day( S : string ) : integer ;

begin
    S := trim( lowercase( S ) ) ;
    if( MinMatch( 'sunday', S, 2 ) ) then
    begin
        Result := 1 ;
    end else
    if( MinMatch( 'monday', S, 1 ) ) then
    begin
        Result := 2 ;
    end else                         
    if( MinMatch( 'tuesday', S, 2 ) ) then
    begin
        Result := 4 ;
    end else
    if( MinMatch( 'wednesday', S, 1 ) ) then
    begin
        Result := 8 ;
    end else
    if( MinMatch( 'thursday', S, 2 ) ) then
    begin
        Result := 16 ;
    end else
    if( MinMatch( 'friday', S, 1 ) ) then
    begin
        Result := 32 ;
    end else
    if( MinMatch( 'saturday', S, 2 ) ) then
    begin
        Result := 64 ;
    end else
    begin
        Result := -1 ;
    end ;
end ; // Access_Day

This function converts a day of week string to an integer.

function Access_Day_Name( S : integer ) : string ;

begin
    case S of
        1 : Result := 'SUNDAY' ;
        2 : Result := 'MONDAY' ;
        4 : Result := 'TUESDAY' ;
        8 : Result := 'WEDNESDAY' ;
        16 : Result := 'THURSDAY' ;
        32 : Result := 'FRIDAY' ;
        64 : Result := 'SATURDAY' ;
        else Result := '' ;
    end ;
end ; // Access_Day_Name

This function converts from a number to a day of week string.

function Get_Day( S : string ; Primary, Secondary : integer ) : integer ;

begin
    S := trim( lowercase( S ) ) ;
    if( MinMatch( 'primary', S, 1 ) ) then
    begin
        Result := Primary ;
    end else
    if( MinMatch( 'secondary', S, 2 ) ) then
    begin
        Result := Secondary ;
    end else
    begin
        Result := Access_Day( S ) ;
    end ;
end ;

This function returns an integer for a passed string. It handles "PRIMARY" and "SECONDARY" by returning the passed values, as appropriate. Otherwise it returns the value for the day.

type TDay_Hour = record
                     Days : integer ;
                     Start_Time, End_Time : integer ;
                 end ;

This structure is used to hold a day/time range. Days is a bit mask with one bit for each day of the week (Sunday is bit 1, Saturday is bit 7). Thus a given instance of the structure can apply to multiple days.

function Parse_Time( S : string ; var Range : TDay_Hour ) : boolean ;

var Minutes_Present : boolean ;
    I : integer ;

begin
    Result := False ;
    I := pos( '-', S ) ;
    if( I = 0 ) then // No range
    begin
        Range.Start_Time := StrToTime( S ) ;
        if( Range.Start_Time = -1 ) then
        begin
            Result := True ;
            exit ;
        end ;
        if( not Minutes_Present ) then
        begin
            Range.End_Time := Range.Start_Time + 60 ;
        end else
        begin
            Range.End_Time := Range.Start_Time ;
        end ;
    end else
    begin
        Range.Start_Time := StrToTime( copy( S, 1, I - 1 ) ) ;
        if( Range.Start_Time = -1 ) then
        begin
            Result := True ;
            exit ;
        end ;
        Range.End_Time := StrToTime( copy( S, I + 1, length( S ) ) ) ;
        if( Range.End_Time = -1 ) then
        begin
            Result := True ;
            exit ;
        end ;
    end ;
end ; // Parse_Time

This function converts a hour/minute specification string to a start and end minute value. It uses StrToTime, which we define next.

    function StrToTime( S : string ) : integer ;

    var I, H, M : integer ;

    begin
        I := pos( ':', S ) ;
        Minutes_Present := I > 0 ;
        if( I = 0 ) then
        begin
            if( not trystrtoint( S, M ) ) then
            begin
                Result := -1 ;
                exit ;
            end ;
            H := strtoint( S ) * 60 ;
            M := 0 ;
        end else
        begin
            if( not trystrtoint( copy( S, 1, I - 1 ), M ) ) then
            begin
                Result := -1 ;
                exit ;
            end ;
            if( not trystrtoint( copy( S, I + 1, length( S ) ), M ) ) then
            begin
                Result := -1 ;
                exit ;
            end ;
            H := strtoint( copy( S, 1, I - 1 ) ) ;
            M := strtoint( copy( S, I + 1, length( S ) ) ) ;
        end ;
        Result := H * 60 + M ;
        if( ( M > 59 ) or ( M < 0 ) ) then
        begin
            Result := -1 ;
        end else
        if( ( H > 23 ) or ( H < 0 ) ) then
        begin
            Result := -1 ;
        end ;
    end ;

This local function converts an hour or hour/minute to an integer, returning -1 if something was invalid.

function Parse_Date( S : string ; var Range : TDay_Hour ;
    Primary, Secondary : integer ) : boolean ;

var I, I1 : integer ;
    D, Start, Stop : string ;
    B, E, H, M : integer ;

begin
    // Set up...
    Result := False ; // Assume success
    fillchar( Range, sizeof( Range ), 0 ) ;

    // Process day(s)...
    I := pos( ',', S ) ;
    if( I > 0 ) then // A comma indicates a day
    begin
        D := copy( S, 1, I - 1 ) ;
        S := copy( S, I + 1, length( S ) ) ;
        I := pos( '-', D + '-' ) ;
        B := Get_Day( copy( D, 1, I - 1 ), Primary, Secondary ) ;
        E := Get_Day( copy( D, I + 1, length( D ) ), Primary, Secondary ) ;
        if( I > length( D ) ) then
        begin
            E := B ;
        end ;
        if( ( E = -1 ) or ( B = -1 ) ) then
        begin
            Result := True ;
            exit ;
        end ;
        while( E >= B ) do // A range of days
        begin
            Range.Days := Range.Days or E ;
            E := E shr 1 ;
        end ;
    end ; // if( I > 0 )

    if( Parse_Time( S, Range ) ) then
    begin
        Result := True ;
    end ;
end ; // Parse_Date

This function handles a complete date/time specification. The majority of the code handles a day or day range. It then calls Parse_Time to handle the hour/minute specification.

function Is_Day( S : string ) : boolean ;

begin
    S := trim( lowercase( S ) ) ;
    Result := MinMatch( 'sunday', S ,2 )
              or
              MinMatch( 'monday', S, 1 )
              or
              MinMatch( 'tuesday', S, 2 )
              or
              MinMatch( 'wednesday', S, 1 )
              or
              MinMatch( 'thursday', S, 2 )
              or
              MinMatch( 'friday', S, 1 )
              or
              MinMatch( 'saturday', S, 2 )
              or
              MinMatch( 'primary', S, 1 )
              or
              MinMatch( 'secondary', S, 2 ) ;
end ;

This function returns true if the passed string is a valid day specification, which may be abbreviated.

function Time_To_String( T : TDay_Hour ) : string ;

var H, M, I : integer ;

begin
    // Setup...
    Result := '' ;

    // Handle day
    if( T.Days <> 0 ) then
    begin
        for I := 0 to 6 do
        begin
            if( ( T.Days and ( 1 shl I ) ) <> 0 ) then
            begin
                Result := Access_Day_Name( 1 shl I ) ;
                break ;
            end ;
        end ;
        for I := 6 downto 0 do
        begin
            if( ( T.Days and ( 1 shl I ) ) <> 0 ) then
            begin
                if( Access_Day_Name( 1 shl I ) <> Result ) then
                begin
                    Result := Result + '-' + Access_Day_Name( 1 shl I ) ;
                    break ;
                end ;
            end ;
        end ;
        Result := Result + ', ' ;
    end ;

    // Handle start time...
    H := T.Start_Time div 60 ;
    M := T.Start_Time - ( H * 60 ) ;
    Result := Result + inttostr( H ) + ':' ;
    if( M < 10 ) then
    begin
        Result := Result + '0' ;
    end ;
    Result := Result + inttostr( M ) ;

    // Handle end time...
    if( T.End_Time > T.Start_Time ) then
    begin
        Result := Result + '-' ;
        H := T.End_Time div 60 ;
        M := T.End_Time - ( H * 60 ) ;
        Result := Result + inttostr( H ) + ':' ;
        if( M < 10 ) then
        begin
            Result := Result + '0' ;
        end ;
        Result := Result + inttostr( M ) ;
    end ;
end ; // Time_To_String

This function returns the string equivalent to a TDay_Hour structure, handling day and time ranges.

Now that we've covered the various support code, in the next article, we will cover the meat of the authorize utility.