AUTHORIZE utility, part 6

In this article, we will look at the implementation of the ADD, COPY, DEFAULT, and MODIFY commands in the Authorize utility.

function TAuth_Responder.Post_Processing : boolean ;

var Component : TUUI_Component ;
    I, I1 : integer ;
    Invert : boolean ;
    Last_Access_Spec, S, P : string ;
    This_Day : integer ;
    Last_Item_Was_Day : boolean ;
    Low_Range, This_Start_Time, New_Time : TDay_Hour ;
    Primary, Secondary : integer ;
    U : TUser ;

begin // TAuth_Responder.Post_Processing
    // Setup...
    Result := True ;
    Primary := 2 or 4 or 8 or 16 or 32 ;
    Secondary := 1 or 64 ;

As we discussed a couple of articles ago, the UUI has callbacks to allow a program to customize the UI. The Post_Processing method is called after all the command-line switches are processed. We also looked at the pre-processing of access restrictions, which we will now make use of.

    // Process through the access restriction switches...
    Last_Access_Spec := '' ;
    while( Access_Switches <> '' ) do
    begin
        Invert := False ;
        S := lowercase( Next_Switch( Access_Switches, P ) ) ;
        P := lowercase( P ) ;
        if( Left( P, 1 ) = '(' ) then
        begin
            P := copy( P, 2, length( P ) ) ;
            if( copy( P, length( P ), 1 ) = ')' ) then
            begin
                setlength( P, length( P ) - 1 ) ;
            end ;
        end ;
        if( P = '' ) then
        begin
            if( MinMatch( S, 'access', 1 ) ) then
            begin
                continue ;
            end ;
            P := Last_Access_Spec ; // Use last specified access
        end ;

During pre-processing, we extracted the access restriction switches to a string which we will now iterate through. Each time through the loop, we get the next switch and remove it from Access_Switches. The loop ends when all of the switches have been processed. S is the switch and P are the parameters (if any). The syntax of the access switches allows for including specifications inside parentheses. The way we process the switches, these parentheses are irrelevant, so we simply remove the pair of parentheses from the current switch if they are present. If no parameters are specified, we default them to the last access specification that we encountered on the line. This handles situations such as the following:


/BATCH=(TUESDAY,8-11)/ACCESS

In this case, the /ACCESS switch "inherits" the /BATCH parameters as if it were specified as:


/ACCESS=(TUESDAY,8-11)

        if( copy( S, 1, 1 ) = 'a' ) then
        begin
            Last_Access_Spec := P ;
            Component := UUI.Get_Component_By_Name( 'accesslist' ) ;
        end else
        if( copy( S, 1, 3 ) = 'noa' ) then
        begin
            Last_Access_Spec := P ;
            Component := UUI.Get_Component_By_Name( 'accesslist' ) ;
            Invert := True ; // Disallow access
        end else
        if( copy( S, 1, 1 ) = 'b' ) then
        begin
            Component := UUI.Get_Component_By_Name( 'batchlist' ) ;
        end else
        if( copy( S, 1, 1 ) = 'i' ) then
        begin
            Component := UUI.Get_Component_By_Name( 'interactivelist' ) ;
        end else
        if( copy( S, 1, 3 ) = 'noi' ) then
        begin
            if( P <> '' ) then
            begin
                Error_Code := AUTH_INVPARM ;
                Result := False ;
                exit ;
            end ;
            Component := UUI.Get_Component_By_Name( 'interactivelist' ) ;
            Component.Clear ;
            continue ;
        end else
        if( copy( S, 1, 1 ) = 'l' ) then
        begin
            Component := UUI.Get_Component_By_Name( 'locallist' ) ;
        end else
        if( copy( S, 1, 1 ) = 'n' ) then
        begin
            Component := UUI.Get_Component_By_Name( 'networklist' ) ;
        end else
        if( copy( S, 1, 1 ) = 'r' ) then
        begin
            Component := UUI.Get_Component_By_Name( 'remotelist' ) ;
        end else

Based on the first character of the access type, we select the appropriate UI component to update. Note that since the we already processed the valid switches earlier, we only need to check the first character of the switch - there won't be any invalid switches here.

        begin
            // /PRIMEDAYS handling...

            // Set defaults...
            Primary := 2 or 4 or 8 or 16 or 32 ;
            Secondary := 1 or 64 ;

            while( P <> '' ) do
            begin
                I := pos( ',', P + ',' ) ;
                S := lowercase( trim( copy( P, 1, I - 1 ) ) ) ;
                P := copy( P, I + 1, length( P ) ) ;
                if( copy( S, 1, 2 ) = 'no' ) then
                begin
                    I := Access_Day( copy( S, 3, length( S ) ) ) ;
                    if( I < 0 ) then
                    begin
                        Error_Code := AUTH_INVDAY ;
                        Result := False ;
                        exit ;
                    end ;
                    I := 1 shl I ;
                    Secondary := Secondary or I ;
                    Primary := Primary and ( not I ) ;
                end else
                begin
                    I := Access_Day( S ) ;
                    if( I < 0 ) then
                    begin
                        Error_Code := AUTH_INVDAY ;
                        Result := False ;
                        exit ;
                    end ;
                    I := 1 shl I ;
                    Primary := Primary or I ;
                    Secondary := Secondary and ( not I ) ;
                end ;
            end ; // while( P <> '' )
        end ;

If the switch doesn't match any of the above, the only possibility is /primary. In this case, we default to primary days of Monday through Friday, and secondard days of Saturday and Sunday. The days are indicated by a bitmask, where Sunday is bit 0 (value of 1) and Saturday is bit 6. Then we iterate through the parameters, processing items delimited by commas. The processing for each item is a matter of converting each day to a bit value (or range of bits) after validating the name of the day. If the name is prefixed with "no", the day is assigned to the secondary days bitmask. Otherwise it is added to the primary days bitmask. Whichever bitmask it is added to, the same bit is removed from the alternate bitmask.

        if( Last_Item_Was_Day ) then
        begin
            Low_Range.Days := This_Day ;
            Process_Access ;
        end ;
    end ; // while( Access_Switches <> '' )

If the last item processed was a day, we add an access item to the appropriate access list. Otherwise, we continue on to the next item in the access specifications. In this way, we can build restriction specifications as we process through the switches.

    if( Operation = Op_Copy ) then
    begin
        if( Add_User( Target, False, 0 ) < 1 ) then
        begin
            UUI.Show_Error( AUTH_ADDERR, 'SYSUAF error' ) ;
            exit ;
        end ;
        U := Get_User( Target ) ;
        Update_User_From_UI( U ) ;
    end else
    if( Operation = Op_Modify ) then
    begin
        U := Get_User( Target ) ;
        Update_User_From_UI( U ) ;
    end ;
end ; // TAuth_Responder.Post_Processing

When we are done processing the access switches, if any, we then process the command. If the command is a copy, we first create the new user, then update the user from the UI. This will match the source account loaded earlier, as modified by switches. If the command is a modify command, the account characteristics were already added to the UI, modified by the switches. We get the specified user and then update it from the UI.

    procedure Process_Access ;

    var I, I1 : integer ;

    begin
        // Remove any current items that conflict with this new time range...
        for I := Component.List_Count - 1 downto 0 do
        begin
            S := Component.List_Value( I ) ;
            Parse_Date( S, This_Start_Time, Primary, Secondary ) ;
            if( ( This_Start_Time.Days and Low_Range.Days ) <> 0 ) then // Overlapped day
            begin
                if( ( This_Start_Time.Start_Time <= Low_Range.End_Time )
                    and
                    ( This_Start_Time.End_Time >= Low_Range.Start_Time )
                  ) then
                begin // Overlapping time ranges
                    Component.List_Delete( I ) ; // Delete old time
                    if( This_Start_Time.Start_Time < Low_Range.Start_Time ) then
                    begin
                        New_Time := This_Start_Time ;
                        New_Time.End_Time := Low_Range.Start_Time - 1 ;
                        Component.Add_To_List( PChar( Time_To_String( New_Time ) ) ) ;
                    end ;
                    if( This_Start_Time.End_Time > Low_Range.End_Time ) then
                    begin
                        New_Time := This_Start_Time ;
                        New_Time.Start_Time := Low_Range.End_Time + 1 ;
                        Component.Add_To_List( PChar( Time_To_String( New_Time ) ) ) ;
                    end ;
                end ;
            end ;
        end ; // for I := 0 to Component.List_Count - 1

        // Add this time to the current item list...
        if( not Invert ) then
        begin
            I1 := Low_Range.Days ;
            for I := 0 to 6 do // Check each day
            begin
                if( ( I1 and ( 1 shl I ) ) <> 0 ) then // Found a day
                begin
                    Low_Range.Days := 1 shl I ;
                    Component.Add_To_List( PChar( Time_To_String( Low_Range ) ) ) ;
                end ;
            end ;
        end ; // if( not Invert )
    end ;

This local function processes the current access specification in S. Since it makes no sense to have conflicting restriction times, we make sure we remove any matched times from the existing access list. The new restriction may completely or partially replace an existing one. If there is a partial overlap, we save the portion(s) outside of the overlap, possibly splitting a single item into two separate ones. For instance, if the existing time is 1 PM to 4 PM, and the new time is 2 PM to 3 PM, the existing time is replaced by two items: one for 1 PM to 2 PM and one for 3 PM to 4 PM.

Finally we add the new restriction to the appropriate Component.

In the next article, we will begin look into the subject of authentication.