windows-xp/Source/XPSP1/NT/sdktools/mkupdate/mkupdate.c

/*++

Copyright Microsoft Corporation, 1996-7, All Rights Reserved.      

Module Name:

    mkupdate.c

Abstract:

    Application for creating the update database file from an
    appropriately structured input update file and maintaining
    the driver version in the resource file.

Author:

     Shivnandan Kaushik

Environment:

    User mode

Revision History:

--*/

#include <windows.h>
#include <stdio.h>
#include <winbase.h>
#include <winioctl.h>
#include <fcntl.h>
#include <stdlib.h>
#include <io.h>
#include <string.h>
#include "mkupdate.h"

//
// Globals
//

PUPDATE_ENTRY UpdateTable;

VOID
GenMSHeader(
    FILE *file,
    CHAR *Filename,
    CHAR *Abstract
    )
/*++
Routine Description:

    Generates the Microsoft recommended header for code files.

Arguments:

  File: Output file pointer
  FileName: Output file name
  Abstract: Description of file

Return Value:
    
   None

--*/
{   
    fprintf(file,"/*++ \n\nCopyright (c) 1996-7  Microsoft Corporation, ");
    fprintf(file,"All Rights Reserved.\n\n");
    fprintf(file,"Copyright (c) 1995-2000 Intel Corporation. This update binary code\n");
    fprintf(file,"is distributed for the sole purpose of being loaded into Intel\n");
    fprintf(file,"Pentium(R) Pro Processor Family  and Pentium(R) 4 Family microprocessors.\n");
    fprintf(file,"All Rights on the binary code are reserved.\n\n");
    fprintf(file,"Module Name:\n\n    %s\n\n",Filename);
    fprintf(file,"Abstract:\n\n    %s\n\n",Abstract);
    fprintf(file,"Author:\n\n    !!!THIS IS A GENERATED FILE. DO NOT DIRECTLY EDIT!!!\n\n");
    fprintf(file,"Revision History:\n\n--*/\n\n");
}
    
BOOL
GetVerifyPutUpdate(
    FILE *OutputFile,
    ULONG UpdateNum,
    ULONG TotalUpdates
    )
/*++
Routine Description:

    Read in an update, verify it and write to data file.

Arguments:

    OutputFile: output file pointer
    UpdateNum: Update number in update list
    TotalUpdates: Total number of updates in update list.

Return Value:
    
    TRUE if writes succeeded else FALSE.

--*/
{
    FILE *UpdateFile;
    CHAR Line[MAX_LINE],UpdateString[MAX_LINE];
    CHAR Filename[MAX_PATH];
    BOOL BeginFound,EndFound;
    ULONG CurrentDword,i,Checksum;
    ULONG UpdateBuffer[sizeof(UPDATE)];
    PUPDATE CurrentUpdate;

    // create the string name of the file to open

    strcpy(Filename,UpdateTable[UpdateNum].CpuSigStr);
    strcat(Filename,"_");
    strcat(Filename,UpdateTable[UpdateNum].UpdateRevStr);
    strcat(Filename,".");
    strcat(Filename,UpdateTable[UpdateNum].FlagsStr);

    UpdateFile = fopen(Filename,"r");

    if (UpdateFile == NULL) {
        fprintf(stdout,"mkupdate:Unable to open update input file %s\n",Filename);
        return(FALSE);
    }

    //
    // Read in each update - scan till beginning of update
    // marked by keyword BEGIN_UPDATE
    //

    BeginFound = FALSE;
    while (fgets(Line,MAX_LINE,UpdateFile) != NULL) {
        if (sscanf(Line,"%s",&UpdateString)) {
            if (strcmp(UpdateString,"BEGIN_UPDATE") == 0) {
                BeginFound = TRUE;
                break;
            }
        }
    }

    if (!BeginFound) {
        fprintf(stdout,"mkupdate:BEGIN_UPDATE not found in update file %s\n",Filename);
        fclose(UpdateFile);
        return(FALSE);
    }

    //
    // scan "update size" forward.
    //

    EndFound = FALSE;
    for (i = 0; i < sizeof(UPDATE)/sizeof(ULONG); i++) {
        if (fgets(Line,MAX_LINE,UpdateFile) != NULL) {
            if (sscanf(Line,"%lx",&CurrentDword)) 
                UpdateBuffer[i] = CurrentDword;
        } else {
            EndFound = TRUE;
            break;
        }
    }

    if (EndFound) {
        fprintf(stdout,"mkupdate:Abnormal termination of update file %s\n",Filename);
        fclose(UpdateFile);
        return(FALSE);
    } else {
        if (fgets(Line,MAX_LINE,UpdateFile) != NULL) {
            if (sscanf(Line,"%s",&UpdateString)) {
                if (strcmp(UpdateString,"END_UPDATE") != 0) {
                    fprintf(stdout,"mkupdate:Update data size in %s incorrect\n",Filename);
                    fclose(UpdateFile);
                    return(FALSE);
                }
            }
        } else {
            fprintf(stdout,"mkupdate:Abnormal termination of update file %s\n",Filename);
            fclose(UpdateFile);
            return(FALSE);
        }
    }
    
    fclose (UpdateFile);

    // Verify Update - Checksum Buffer

    Checksum = 0;
    for (i = 0; i < sizeof(UPDATE)/sizeof(ULONG); i++) {
        Checksum += UpdateBuffer[i];
    }

    if (Checksum){
        fprintf(stdout,"mkupdate:Incorrect update checksum in %s\n",Filename);
        return(FALSE);
    } 

    //
    // Verify update - check if processor signature, update revision
    // and processor flags match that specified in listing file and 
    // update data file name
    //

    CurrentUpdate = (PUPDATE) UpdateBuffer;

    if ((CurrentUpdate->Processor.u.LongPart != 
            UpdateTable[UpdateNum].CpuSignature)){
        fprintf(stdout,"mkupdate:incorrect processor signature in %s: ",Filename); 
        fprintf(stdout,"expected 0x%lx got 0x%lx\n",
                        UpdateTable[UpdateNum].CpuSignature,
                        CurrentUpdate->Processor.u.LongPart); 
        return(FALSE);
    }

    if (CurrentUpdate->UpdateRevision != 
            UpdateTable[UpdateNum].UpdateRevision){
        fprintf(stdout,"mkupdate:incorrect update revision in %s: ",Filename); 
        fprintf(stdout,"expected 0x%lx got 0x%lx\n",
                        UpdateTable[UpdateNum].UpdateRevision,
                        CurrentUpdate->UpdateRevision); 
        return(FALSE);
    }

    if ((CurrentUpdate->ProcessorFlags.u.LongPart != 
            UpdateTable[UpdateNum].ProcessorFlags)){
        fprintf(stdout,"mkupdate:incorrect processor flags in %s: ",Filename); 
        fprintf(stdout,"expected 0x%lx got 0x%lx\n",
                        UpdateTable[UpdateNum].ProcessorFlags,
                        CurrentUpdate->ProcessorFlags.u.LongPart); 
        return(FALSE);
    }

    //
    // Input update validated. Write out validated update
    //

    fprintf(OutputFile,"    {\n");
    for (i = 0; i < sizeof(UPDATE)/sizeof(ULONG); i++) {
        fprintf(OutputFile,"        0x%.8x",UpdateBuffer[i]);
        if (i == sizeof(UPDATE)/sizeof(ULONG) - 1) {
            fprintf(OutputFile,"\n");
        } else {
            fprintf(OutputFile,",\n");
        }
    }
    fprintf(OutputFile,"    }");
    if (UpdateNum != TotalUpdates-1) {
        fprintf(OutputFile,",\n");
    }
    
    return(TRUE);
}

VOID
BuildUpdateInfoTable(
    FILE *OutputFile,
    ULONG TotalUpdates
    )
/*++
Routine Description:

    Write the CPU Signature and Processor Flags into the 
    Build Table and adds NULL for the MDL Item.

Arguments:

    OutputFile   :  output file pointer
    TotalUpdates :  Total number of updates in update list.

Return Value:
    
   None:

--*/
{   
    ULONG CpuSignature, ProcessorFlags, i;

    fprintf(OutputFile, "//\n// Update Info Table containing the CPU Signatures,\n");
    fprintf(OutputFile, "// Processor Flags, and MDL Pointers.  The MDL Pointers\n");
    fprintf(OutputFile, "// are initialized to NULL.  They get populated as pages\n");
    fprintf(OutputFile, "// corresponding to specific updates are locked in memory.\n");
    fprintf(OutputFile, "// This table contains the CPU Signatures and Processor Flags.\n");
    fprintf(OutputFile, "// in the same order as in the update database.  Therefore,\n");
    fprintf(OutputFile, "// the Update Info Table self-indexes to the right update.\n//\n\n");
    fprintf(OutputFile, "UPDATE_INFO UpdateInfo[] = {\n");

    //
    // Add each entry for the info
    //

    for (i = 0; i < TotalUpdates; i++) {
        CpuSignature = strtoul(UpdateTable[i].CpuSigStr, NULL, 16);
        ProcessorFlags = strtoul(UpdateTable[i].FlagsStr, NULL, 16);
        if (i < (TotalUpdates - 1)) {
            fprintf(OutputFile, "        {0x%x, 0x%x, NULL},\n", CpuSignature, ProcessorFlags);
        } else {
            fprintf(OutputFile, "        {0x%x, 0x%x, NULL}\n", CpuSignature, ProcessorFlags);
        }
    }
    
    //
    // generate closing code for the update info definition
    //

    fprintf(OutputFile, "};\n");

    return;
}

ULONG
PopulateUpdateList(
    CHAR *ListingFile
    )
/*++
Routine Description:

    Populates the update list with (processor signature, update revision)
    pairs included in the update listing file and returns the number of 
    updates found.

Arguments:

    ListingFile

Return Value:
    
   Number of updates in the update list. 0 if no updates found or any
   error encountered.

--*/
{
    CHAR Line[MAX_LINE],UpdateString[MAX_LINE];
    CHAR CpuSigStr[MAX_LINE],UpdateRevStr[MAX_LINE];
    CHAR FlagsStr[MAX_LINE];
    BOOL BeginFound,EndFound,Error;
    FILE *TmpFilePtr;
    ULONG NumUpdates,i;
    ULONG CpuSignature,UpdateRevision,ProcessorFlags;

#ifdef DEBUG
    fprintf(stderr,"listing file %s\n",ListingFile);
#endif
    // Open the update listing file

    TmpFilePtr = fopen(ListingFile,"r");

    if (TmpFilePtr == NULL) {
        fprintf(stdout,"mkupdate:Unable to open update listing file %s\n",ListingFile);
        return(0);
    };

    //
    // Scan for beginning of the update list marked by
    // BEGIN_UPDATE_LIST keyword
    //
    
    BeginFound = FALSE;
    while ((!BeginFound) && (fgets(Line,MAX_LINE,TmpFilePtr) != NULL)) {
        if (sscanf(Line,"%s",&UpdateString)) {
            if (strcmp(UpdateString,"BEGIN_UPDATE_LIST") == 0) {
                BeginFound = TRUE;
            }
        }
    }

    if (!BeginFound) {
        fprintf(stdout,"mkupdate:BEGIN_UPDATE_LIST not found in update listing file %s\n",ListingFile);
        fclose(TmpFilePtr);
        return(0);
    };

    //
    // Scan for end of the update list marked by
    // END_UPDATE_LIST keyword and count # updates.
    //
    
    NumUpdates = 0;
    EndFound = FALSE;   
    while ((!EndFound) && (fgets(Line,MAX_LINE,TmpFilePtr) != NULL)) {
        if (sscanf(Line,"%s",&UpdateString)) {
            if (strcmp(UpdateString,"END_UPDATE_LIST") == 0) {
                EndFound = TRUE;
            } else {
                NumUpdates++;
            }
        }
    }
    fclose(TmpFilePtr);
    if (!EndFound) {
        fprintf(stdout,"mkupdate:END_UPDATE_LIST not found in update listing file %s\n",ListingFile);
        return(0);
    }
    
    //
    // If legal file format and non-zero number of updates are found
    // then read the processor signatures and update revisions into
    // the update list.
    //
    
    if (NumUpdates) {

        // allocate memory for storing cpu signatures 

        UpdateTable = (UPDATE_ENTRY *) malloc(NumUpdates*sizeof(UPDATE_ENTRY));
        if (UpdateTable == NULL){
            fprintf(stdout,"mkupdate:Error: Memory Allocation Error\n");
            return(0);  
        }

        TmpFilePtr = fopen(ListingFile,"r");
        if (TmpFilePtr == NULL) {
            fprintf(stdout,"mkupdate:Unable to open update listing file %s\n",ListingFile);
            return(0);
        };

        while ((fgets(Line,MAX_LINE,TmpFilePtr) != NULL)) {
            if (sscanf(Line,"%s",&UpdateString)) {
                if (strcmp(UpdateString,"BEGIN_UPDATE_LIST") == 0) {
                    break;
                }
            }
        }

        // Scan the listing file and populate the update table

        Error = FALSE;
        for (i = 0; i < NumUpdates; i++) {
            if (fgets(Line,MAX_LINE,TmpFilePtr) == NULL) {
                fprintf(stdout,"mkupdate: Abnormal termination in update listing file %s\n",
                    ListingFile);
                Error = TRUE;
                break;
            }

            if (sscanf(Line,"%s %s %s",&CpuSigStr,&UpdateRevStr,&FlagsStr) != 3) {
                fprintf(stdout,"mkupdate: Incorrect format of update listing file %s\n",
                    ListingFile);
                Error = TRUE;
                break;
            }
#ifdef DEBUG
            fprintf(stderr,"CpuSig %s Update Rev %s Processor Flags %s,\n",CpuSigStr,
                    UpdateRevStr,FlagsStr);
#endif
            if (sscanf(CpuSigStr,"%lx",&CpuSignature) != 1) {
                fprintf(stdout,"mkupdate: Incorrect Processor Signature in update listing file %s\n",
                    ListingFile);
                Error = TRUE;
                break;
            }
            if (sscanf(UpdateRevStr,"%lx",&UpdateRevision)!= 1) {
                fprintf(stdout,"mkupdate: Incorrect Update Revision of update listing file %s\n",
                    ListingFile);
                Error = TRUE;
                break;
            }
            if (sscanf(FlagsStr,"%lx",&ProcessorFlags)!= 1) {
                fprintf(stdout,"mkupdate: Incorrect Processor Flags in update listing file %s\n",
                    ListingFile);
                Error = TRUE;
                break;
            }

#ifdef DEBUG
            fprintf(stderr,"CpuSig 0x%lx Update Rev 0x%lx Flags 0x%lx,\n",
                    CpuSignature,UpdateRevision,ProcessorFlags);
#endif
            strcpy(UpdateTable[i].CpuSigStr,CpuSigStr);
            UpdateTable[i].CpuSignature = CpuSignature;
            strcpy(UpdateTable[i].UpdateRevStr,UpdateRevStr);
            UpdateTable[i].UpdateRevision = UpdateRevision;
            strcpy(UpdateTable[i].FlagsStr,FlagsStr);
            UpdateTable[i].ProcessorFlags = ProcessorFlags;
        }

        fclose(TmpFilePtr);
        if (Error) {
            NumUpdates = 0;
            free(UpdateTable);
        }
    }

    return(NumUpdates);
}

VOID
CleanupDataFile(
    VOID
    )
/*++
Routine Description:

    If any operation during the creation of the new Data file fails, 
    then delete it so that the build for the driver will fail.

Arguments:

    None

Return Value:
    
    None

--*/
{
    DeleteFile(UPDATE_DATA_FILE);            
}

BOOL
SanitizeUpdateList(
    ULONG NumUpdates
    )
/*++
Routine Description:

    Sanitizes the update list. Checking for duplicate processor 
    signatures.

Arguments:

  NumUpdates: Number of updates in the update list.

Return Value:
    
    TRUE is list clean else FALSE.

--*/
{
    ULONG i,j;
    PROCESSOR_FLAGS ProcessorFlags;

    //
    // Check for garbage values in the update table
    //

    for (i = 0; i < NumUpdates-1; i++) {
        if (UpdateTable[i].CpuSignature == 0) {
            fprintf(stdout,"mkupdate: Error: incorrect processor signature in update list.\n");
            return(FALSE);    
        }
        if (UpdateTable[i].UpdateRevision == 0) {
            fprintf(stdout,"mkupdate: Error: incorrect update revision in update list.\n");
            return(FALSE);    
        }

        if (UpdateTable[i].ProcessorFlags != 0) {

            // Only a single bit must be set

            ProcessorFlags.u.LongPart = UpdateTable[i].ProcessorFlags;

            if (((ProcessorFlags.u.hw.Slot1) && 
                    (ProcessorFlags.u.LongPart & MASK_SLOT1)) ||
                ((ProcessorFlags.u.hw.Mobile) && 
                    (ProcessorFlags.u.LongPart & MASK_MOBILE)) ||
                ((ProcessorFlags.u.hw.Slot2) && 
                    (ProcessorFlags.u.LongPart & MASK_SLOT2)) ||
                ((ProcessorFlags.u.hw.MobileModule) && 
                    (ProcessorFlags.u.LongPart & MASK_MODULE)) ||
                ((ProcessorFlags.u.hw.Reserved1) && 
                    (ProcessorFlags.u.LongPart & MASK_RESERVED1)) ||
                ((ProcessorFlags.u.hw.Reserved2) && 
                    (ProcessorFlags.u.LongPart & MASK_RESERVED2)) ||
                ((ProcessorFlags.u.hw.Reserved3) && 
                    (ProcessorFlags.u.LongPart & MASK_RESERVED3)) ||
                ((ProcessorFlags.u.hw.Reserved4) && 
                    (ProcessorFlags.u.LongPart & MASK_RESERVED4))) {
                fprintf(stdout,"mkupdate: Error: incorrect processor flags in update list.\n");
                return(FALSE);    
            }
        }
    }
     
    for (i = 0; i < NumUpdates-1; i++) {
        for (j = i+1; j < NumUpdates; j++) {
            if ((UpdateTable[i].CpuSignature == UpdateTable[j].CpuSignature) 
                && (UpdateTable[i].ProcessorFlags == UpdateTable[j].ProcessorFlags)){
                fprintf(stdout,"mkupdate:Error: Duplicate processor entry 0x%lx:0x%lx in update list\n",
                        UpdateTable[i].CpuSignature,UpdateTable[i].ProcessorFlags);
                return(FALSE);
            }
        }
    }
    return(TRUE);
}

int
__cdecl main(
    int argc,
    LPSTR argv[]
    )
/*++
Routine Description:
    Scans the processor update listing file, pick up the specified 
    processor updates, verify the updates and generate the update 
    data file to be used by the update driver. Generates the 
    version numbers and strings to be included in the 
    resource definition file.

Arguments:
    
      listing file: list of the processor updates to be included in 
                    the driver.

Return Value:

--*/
{
    FILE    *DataOut, *RCFile,*VerFile;
    ULONG   NumUpdates,i;
    CHAR    Line[MAX_LINE];
    CHAR    *CurrentDataVersionString;
    BOOL    VerFileFound;
    CHAR    VersionFile[MAX_LINE];
    CHAR    *VersionDirectory;

    VersionFile[0] = 0;

    if (argc < 2) {
        fprintf(stdout,"%s: Usage: %s <patch listing file>\n",argv[0],argv[0]);
        exit(0);
    }
    
#ifdef DEBUG
    fprintf(stderr,"listing file %s\n",argv[1]);
#endif
    
    // Open generated file UPDATE_DATA_FILE. Delete previous file if any.

    DataOut=fopen(UPDATE_DATA_FILE,"w");

    if (DataOut == NULL) {
        fprintf(stdout,"mkupdate:Unable to open update data file %s\n",UPDATE_DATA_FILE);
        exit(0);
    }

    // Scan listing file and store all the CPU signatures in update table

    NumUpdates = PopulateUpdateList(argv[1]);
    if (NumUpdates == 0) {
        fprintf(stdout,"mkupdate:Listing file %s: Incorrect format or no updates specified.\n",
                argv[1]);
        fclose(DataOut);
        exit(0);
    }

    //
    // Dynamically allocate the size for CurrentDataVersionString
    //

    CurrentDataVersionString = (CHAR*)malloc(NumUpdates * UPDATE_VER_SIZE);

    if (CurrentDataVersionString == NULL) {
        fprintf(stdout,"mkupdate:Listing file %s: Failed to allocate memory.\n",
                argv[1]);
        fclose(DataOut);
        exit(0);
    }

    // Sanitize the update list

    if (!SanitizeUpdateList(NumUpdates)) {
        fclose(DataOut);
        DeleteFile(UPDATE_DATA_FILE);
        free(CurrentDataVersionString);
        exit(0);
    }

    // Generate the data file. First generate all headers

    GenMSHeader(DataOut,UPDATE_DATA_FILE,"Processor updates.");

    // generate the data segment alloc pragmas

    fprintf(DataOut,"\n#ifdef ALLOC_DATA_PRAGMA\n");
    fprintf(DataOut,"#pragma data_seg(\"PAGELK\")\n");
    fprintf(DataOut,"#endif\n\n");

    // generate the update table definition

    fprintf(DataOut,"//\n// Updates data\n//\n\n");
    fprintf(DataOut,"UPDATE UpdateData[] = {\n");
    
    // include each update

    for (i=0; i < NumUpdates; i++) {
        if (!GetVerifyPutUpdate(DataOut,i,NumUpdates)) {
            fprintf(stdout,"mkupdate:Error: processing update data file %s_%s.%s\n",
                UpdateTable[i].CpuSigStr,UpdateTable[i].UpdateRevStr,
                UpdateTable[i].FlagsStr);
            fclose(DataOut);
            CleanupDataFile();
            free(CurrentDataVersionString);
            exit(0);
        }
    }
    
    // generate closing code for the update table definition

    fprintf(DataOut,"\n};\n");

    // generate the closing data segment alloc pragmas

    fprintf(DataOut,"\n#ifdef ALLOC_DATA_PRAGMA\n");
    fprintf(DataOut,"#pragma data_seg()\n");
    fprintf(DataOut,"#endif\n\n");

    //
    // Generate the Update Info Table containing the
    // processor signatures, processor flags, and 
    // pointers to MDLs (initialized to NULL)
    //

    BuildUpdateInfoTable(DataOut, NumUpdates);
    
    fclose(DataOut);

    // Generate the version file. Delete previous file if any.

    RCFile = fopen(UPDATE_VERSION_FILE,"w");

    if (RCFile == NULL) {
        fprintf(stdout,"%s: Unable to open version file %s\n",
                argv[0],UPDATE_VERSION_FILE);
        free(CurrentDataVersionString);
        exit(0);
    }
    
    // Generate header

    GenMSHeader(RCFile,UPDATE_VERSION_FILE,"Version information for update device driver.");

    //
    // Open common.ver. If found generate the dataversion string and 
    // copy everything to our RC file and insert our
    // string definitions in the StringFileInfo resource section. We need
    // to do this because inclusion of common.ver prevents the addition 
    // of new string defines in the stringfileinfo block. If common.ver
    // is not found in the expected place we only include it expecting the 
    // appropriate settings in the build environment to locate the file.
    // 

    //
    // Generate the common.ver path name
    //
    
    //
    // Obtain the Drive Name
    //

    VersionDirectory = getenv( "_NTDRIVE" );

    if (VersionDirectory == NULL) {
        fprintf(stdout,"%s: Unable to obtain _NTDRIVE ENV variable\n",argv[0]);
        fclose(RCFile);
        free(CurrentDataVersionString);
        exit(0);
    }
 
    strcpy(VersionFile, VersionDirectory);

    //
    // Obtain the Base Directory
    //

    VersionDirectory = getenv( "_NTROOT" );

    if (VersionDirectory == NULL) {
        fprintf(stdout,"%s: Unable to obtain _NTROOT ENV variable\n",argv[0]);
        fclose(RCFile);
        free(CurrentDataVersionString);
        exit(0);
    }

    strcat(VersionFile, VersionDirectory);
    strcat(VersionFile, "\\public\\sdk\\inc\\common.ver");

    VerFile = fopen(VersionFile,"r");

    if (VerFile == NULL) {
        fprintf(stdout,"%s: Unable to open version file common.ver\n",argv[0]);
        VerFileFound = FALSE;
    } else {
        VerFileFound = TRUE;
    }

    if (VerFileFound) {

        // Construct data version string from update listing table

        strcpy(CurrentDataVersionString,"\"");
        for (i=0; i < NumUpdates; i++) {
            strcat(CurrentDataVersionString,UpdateTable[i].CpuSigStr);
            strcat(CurrentDataVersionString,"-");
            strcat(CurrentDataVersionString,UpdateTable[i].FlagsStr);
            strcat(CurrentDataVersionString,",");
            strcat(CurrentDataVersionString,UpdateTable[i].UpdateRevStr);
            if (i != NumUpdates-1)
                strcat(CurrentDataVersionString,",");
        }
        strcat(CurrentDataVersionString,"\"");

#ifdef DEBUG
        fprintf(stderr,"DataVersionString %s\n",CurrentDataVersionString);
#endif
        
        fprintf(RCFile,"#define VER_DATAVERSION_STR    %s\n",
                CurrentDataVersionString);

        // Scan till string info block into version file, add our 
        // definition and scan till end

        while (fgets(Line,MAX_LINE,VerFile) != NULL) {
            fputs(Line,RCFile);
            if (strstr(Line,"VALUE") && strstr(Line,"ProductVersion") 
                && strstr(Line,"VER_PRODUCTVERSION_STR")){
                fprintf(RCFile,"            VALUE \"DataVersion\",     VER_DATAVERSION_STR\n");
            }
        }
    } else {
        
        // version file not found. Cannot define the dataversion
        // and codeversion strings. Only include common.ver

        fprintf(RCFile,"\n\n#include \"common.ver\"\n");
    }
    
    fclose(RCFile);
    fclose(VerFile);
    free(CurrentDataVersionString);

    return(0);
}