windows-nt/Source/XPSP1/NT/base/ntsetup/mpk/imagpart/imagpart.c

#include "imagpart.h"

#include <malloc.h>


typedef struct _HANDLES {
    HPARTITION SourcePartitionHandle;
    UINT OutputFileHandle,BitmapFileHandle;
} HANDLES, *PHANDLES;

//
// Global data
//
CMD_LINE_ARGS CmdLineArgs;
FPVOID IoBuffer,OriginalIoBuffer;
char OutputFilename[256];
char BitmapFilename[256];
ULONG CheckSum;
ULONG BytesCRC;

//
// Text for the program
//
char *textNoPartitions;
char *textSourcePrompt;
char *textTransferringFsStructs;
char *textPartOpenError;
char *textFileReadFailed;
char *textTransferringClusters;
char *textCombiningFiles;
char *textReadFailedAtSector;
char *textOOM;
char *textDone;
char *textFileWriteError;
char *textCantCreateNewFile;
char *textSelectOutput;
char *textDisk;
char *textPaddedMbCount;
char *textInvalidSelection;
char *textUsage;
char *textCantCreateFile;
char *textScanningFat;
char *textNtfsUnsupportedConfig;
char *textNtfsCorrupt;
char *textInitNtfsDataStruct;
char *textNtfsBuildingBitmap;
char *textProcessingNtfsBitmap;
char *textUnsupportedFs;
char *textChecksum;
char *textBytesProcessed;

MESSAGE_STRING TextMessages[] = { { &textNoPartitions,1           },
                                  { &textSourcePrompt,2           },
                                  { &textTransferringFsStructs,3  },
                                  { &textPartOpenError,4          },
                                  { &textFileReadFailed,5         },
                                  { &textTransferringClusters,6   },
                                  { &textCombiningFiles,7         },
                                  { &textReadFailedAtSector,8     },
                                  { &textOOM,9                    },
                                  { &textDone,11                  },
                                  { &textFileWriteError,12        },
                                  { &textCantCreateNewFile,17     },
                                  { &textSelectOutput,18          },
                                  { &textDisk,20                  },
                                  { &textPaddedMbCount,21         },
                                  { &textInvalidSelection,22      },
                                  { &textUsage,25                 },
                                  { &textCantCreateFile,26        },
                                  { &textScanningFat,27           },
                                  { &textNtfsUnsupportedConfig,29 },
                                  { &textNtfsCorrupt,30           },
                                  { &textInitNtfsDataStruct,31    },
                                  { &textNtfsBuildingBitmap,32    },
                                  { &textProcessingNtfsBitmap,33  },
                                  { &textUnsupportedFs,34         },
                                  { &textChecksum,35              },
                                  { &textBytesProcessed,36        }
                                };


BOOL
DoIt(
    IN PHANDLES Handles
    );

BOOL
DetermineAndOpenSource(
    IN  UINT        PartitionCount,
    OUT HPARTITION *SourcePartitionHandle
    );

BOOL
DetermineAndCreateOutput(
    OUT UINT *OutputFileHandle,
    OUT UINT *BitmapFileHandle
    );

BOOL
DetermineFsAndInitVolumeData(
    IN  HPARTITION        PartitionHandle,
    OUT FilesystemType   *FsType,
    OUT PPARTITION_IMAGE  PartitionImage
    );

BOOL
TransferFsStructsToOutput(
    IN HPARTITION PartitionHandle,
    IN UINT       FileHandle,
    IN ULONG      SectorCount
    );

BOOL
TransferUsedClustersToOutput(
    IN HANDLES         *Handles,
    IN PARTITION_IMAGE *PartitionImage
    );

BOOL
AppendClusterMapToOutput(
    IN HANDLES         *Handles,
    IN PARTITION_IMAGE *PartitionImage
    );



int
main(
    IN int   argc,
    IN char *argv[]
    )
{
    UINT PartCount;
    BOOL b;
    HANDLES Handles;

    if(!GetTextForProgram(argv[0],TextMessages,sizeof(TextMessages)/sizeof(TextMessages[0]))) {
        fprintf(stderr,"Unable to find messages for program\n");
        return(FAILURE);
    }

    if(!ParseArgs(argc,argv,TRUE,"DIQTXY",&CmdLineArgs)) {
        fprintf(stderr,textUsage);
        fprintf(stderr,"\n");
        return(FAILURE);
    }
    _Log("Begin imagpart\n");
    //
    // Allocate a maximally sized i/o buffer right up front.
    //
    _Log("Allocating Track Buffer.\n");
    if(!AllocTrackBuffer(63,&IoBuffer,&OriginalIoBuffer)) {
        fprintf(stderr,"%s\n",textOOM);
        b = FALSE;
        goto c0;
    }

    _Log("Scanning partition tables...\n");
    PartCount = InitializePartitionList();
    if(!PartCount) {
        fprintf(stderr,"%s\n",textNoPartitions);
        b = FALSE;
        goto c1;
    }

    //
    // Get the source partition and target filename.
    // The source partition is opened and the target filename is created.
    //
    _Log("Determining target partition...\n");
    b = DetermineAndOpenSource(PartCount,&Handles.SourcePartitionHandle);
    if(!b) {
        goto c1;
    }

    printf("\n\n");

    _Log("Determining output file...\n");
    b = DetermineAndCreateOutput(&Handles.OutputFileHandle,&Handles.BitmapFileHandle);
    if(!b) {
        goto c2;
    }    

    CheckSum = CRC32_INITIAL_VALUE;
    BytesCRC = 0;

    _Log("Starting image transfer...\n");
    b = DoIt(&Handles);

    printf(textChecksum, OutputFilename, CheckSum);
    printf("\n");
    printf(textBytesProcessed, BytesCRC);

    _dos_close(Handles.OutputFileHandle);
    _dos_close(Handles.BitmapFileHandle);
    FlushDisks();
    if(!CmdLineArgs.Test) {
        unlink(BitmapFilename);
        if(!b) {
            unlink(OutputFilename);
        }
    }
c2:
    ClosePartition(Handles.SourcePartitionHandle);
c1:
    free(OriginalIoBuffer);
c0:
    if(b) {
        printf("\n%s\n",textDone);
    }
    _Log("Done.\n");

    return(b ? SUCCESS : FAILURE);
}


BOOL
DetermineAndOpenSource(
    IN  UINT        PartitionCount,
    OUT HPARTITION *SourcePartitionHandle
    )

/*++

Routine Description:

    This routine prompts the user to select a partition to be imaged,
    from the list of all partitions that are visible on all drives.
    The selected partition is opened for the caller.

Arguments:

    PartitionCount - supplies the number of partitions on all drives,
        as returned by InitializePartitionList().

    SourcePartitionHandle - in the success case, receives the handle
        to the selected partition.

Return Value:

    Boolean value indicating outcome. If false, a message will have been
    printed explaining why.

--*/

{
    UINT Selection;

    if(CmdLineArgs.Quiet) {
        Selection = 0;
    } else {
        Selection = SelectPartition(
                        PartitionCount,
                        textSourcePrompt,
                        NULL,
                        textDisk,
                        textPaddedMbCount,
                        textInvalidSelection
                        );
    }

    *SourcePartitionHandle = OpenPartition(Selection);
    if(!(*SourcePartitionHandle)) {
        fprintf(stderr,"%s\n",textPartOpenError);
        return(FALSE);
    }
    _Log("Partition opened sucessfully.\n");
    return(TRUE);
}


BOOL
DetermineAndCreateOutput(
    OUT UINT *OutputFileHandle,
    OUT UINT *BitmapFileHandle
    )

/*++

Routine Description:

    This routine prompts the user to enter a filename that will contain
    the output partition image. The file is created (it must not already
    exist). In addition a temporary file named $CLUSMAP.TMP will be
    created in the same directory. Any file with that name is overwritten.

Arguments:

    OutputFileHandle - in the success case, receives a handle
        to the created output file, which will be 0-length.

    BitmapFileHandle - in the success case, receives a handle to the
        created $CLUMAP.TMP file, which will be 0-length.

Return Value:

    Boolean value indicating outcome. If false, a message will have been
    printed explaining why.

--*/

{
    char *p;

    if(CmdLineArgs.ImageFile) {
        printf("%s %s\n",textSelectOutput,CmdLineArgs.ImageFile);
        strcpy(OutputFilename,CmdLineArgs.ImageFile);
        goto gotit;
    }

    //
    // Prompt the user for a filename.
    //
    prompt:
    printf("%s ",textSelectOutput);
    gets(OutputFilename);

    //
    // Attempt to create the file
    //
    gotit:
    if(_dos_creatnew(OutputFilename,_A_NORMAL,OutputFileHandle)) {
        fprintf(stderr,"\n");
        fprintf(stderr,textCantCreateNewFile,OutputFilename);
        fprintf(stderr,"\n");
        goto prompt;
    }
    _Log("Output file name is %s\n",OutputFilename);
    _Log("Successfully created output file.\n");

    //
    // Form the name of the temp file for the cluster bitmap
    //
    strcpy(BitmapFilename,OutputFilename);
    if(p = strrchr(BitmapFilename,'\\')) {
        p++;
    } else {
        if(BitmapFilename[1] == ':') {
            p = BitmapFilename+2;
        } else {
            p = BitmapFilename;
        }
    }
    strcpy(p,"$CLUSMAP.TMP");

    if(_dos_creat(BitmapFilename,_A_NORMAL,BitmapFileHandle)) {
        _dos_close(*OutputFileHandle);
        unlink(OutputFilename);
        fprintf(stderr,"\n");
        fprintf(stderr,textCantCreateFile,BitmapFilename);
        fprintf(stderr,"\n");
        _Log("FAILED creating temporary cluster bitmap file.\n");
        return(FALSE);
    }
    _Log("Successfully created temporary cluster bitmap file.\n");
    return(TRUE);
}


BOOL
DoIt(
    IN PHANDLES Handles
    )
{
    FilesystemType FsType;
    PARTITION_IMAGE PartitionImage;
    BOOL b;
    UINT Written;
    UINT Read;

    memset(&PartitionImage,0,sizeof(PARTITION_IMAGE));
    PartitionImage.Signature = PARTITION_IMAGE_SIGNATURE;
    PartitionImage.Size = sizeof(PARTITION_IMAGE);

    //
    // Determine file system and initialize various data about the volume.
    //
    _Log("Determining Filesystem and Volume Data...\n");
    if(!DetermineFsAndInitVolumeData(Handles->SourcePartitionHandle,&FsType,&PartitionImage)) {
        return(FALSE);
    }

    //
    // Build the cluster bitmap. One bit per cluster, 0=unused, 1=used.
    // The cluster bitmap goes into a temporary file, since we'll need
    // to append it to the actual data later.
    //
    _Log("Building cluster bitmap...\n");
    b = BuildClusterBitmap(
            FsType,
            Handles->SourcePartitionHandle,
            Handles->BitmapFileHandle,
            &PartitionImage
            );

    if(!b) {
        return(FALSE);
    }

    //
    // Write the partition image header into the output file.
    //
    _Log("Initializing image header...\n");
    memset(IoBuffer,0,512);
    memmove(IoBuffer,&PartitionImage,sizeof(PARTITION_IMAGE));
    if(_dos_write(Handles->OutputFileHandle,IoBuffer,512,&Written) || (Written != 512)) {
        fprintf(stderr,"\n%s\n",textFileWriteError);
        _Log("Error: Failed writing image header!\n");
        return(FALSE);
    }

    //
    // the CRC checking code in the other modules assumes the following is true
    // when the CRC stored in the image file was computed: 
    //
    //    ((PPARTITION_IMAGE)IoBuffer)->BitmapRelocationStart = 0;
    //    ((PPARTITION_IMAGE)IoBuffer)->BootRelocationStart = 0;
    //    ((PPARTITION_IMAGE)IoBuffer)->Flags = 0;
    //

    CheckSum = CRC32Compute( IoBuffer, 512, CheckSum);
    BytesCRC += 512;

    //
    // Transfer the file system reserved area into the output file.
    //
    _Log("Transferring fs reserved areas to image file...\n");
    b = TransferFsStructsToOutput(
            Handles->SourcePartitionHandle,
            Handles->OutputFileHandle,
            PartitionImage.NonClusterSectors
            );

    if(!b) {
        _Log("Error: Failed writing fs reserved areas to image file!\n");
        return(FALSE);
    }

    //
    // Transfer the used clusters into the output file.
    //
    _Log("Transferring used clusters to image file...\n");
    b = TransferUsedClustersToOutput(Handles,&PartitionImage);
    if(!b) {
        _Log("Error: Failed transferring used clusters to image file...\n");
        return(FALSE);
    }

    //
    // Append the cluster map to the output file.
    //
    _Log("Transferring cluster map to image file...\n");
    b = AppendClusterMapToOutput(Handles,&PartitionImage);
    if(!b) {
        _Log("Error: FAILED transferring cluster map to image file...\n");
        return(FALSE);
    }

    //
    // Set the checksum.
    //

    memset(IoBuffer,0,512);

    // seek to the start of the file
    if(DosSeek(Handles->OutputFileHandle,0,DOSSEEK_START) != 0) {
        fprintf(stderr,"\n%s\n",textFileWriteError);
        return(FALSE);
    }
    // read the header in
    if(_dos_read(Handles->OutputFileHandle,IoBuffer,512,&Read) || (Read != 512 )) {
        fprintf(stderr,"\n%s\n",textFileWriteError);
        return(FALSE);
    }
       
    ((PPARTITION_IMAGE)IoBuffer)->CRC = CheckSum;
    _Log("Image file (%s) checksum = 0x%08lx\n", OutputFilename, CheckSum);
    _Log("Total bytes processed = 0x%08lx\n",BytesCRC);

    // seek to the start of the file
    if(DosSeek(Handles->OutputFileHandle,0,DOSSEEK_START) != 0) {
        fprintf(stderr,"\n%s\n",textFileWriteError);
        _Log("Error: Failed writing image CRC!\n");        
        return(FALSE);
    }
    // write out the modified image header with the CRC
    if(_dos_write(Handles->OutputFileHandle,IoBuffer,512,&Written) || (Written != 512)) {
        fprintf(stderr,"\n%s\n",textFileWriteError);
        _Log("Error: Failed writing image CRC!\n");        
        return(FALSE);
    }

    return b;
}


BOOL
DetermineFsAndInitVolumeData(
    IN  HPARTITION        PartitionHandle,
    OUT FilesystemType   *FsType,
    OUT PPARTITION_IMAGE  PartitionImage
    )

/*++

Routine Description:

    This routine determines the file system on the source partition
    (fat, ntfs, or other) and initializes sector and cluster count
    values in a PARTITION_IMAGE structure based on the volume's
    characteristics.

Arguments:

    PartitionHandle - supplies handle to the source partition

    FsType - receives the file system type.

    PartitionImage - receives volume-related sector and cluster counts.
        The following members are filled in:

            TotalSectorCount
            NonClusterSectors
            ClusterCount
            SectorsPerCluster
            SystemId

Return Value:

    Boolean value indicating outcome. If false, a message will have been
    printed out explaining why.

--*/

{
    BOOL b;
    UINT DiskId;
    ULONG dontcare;

    if(FatIsFat(PartitionHandle)) {
        *FsType = FilesystemFat;
        _Log("    The partition is FAT...\n");
        b = FatInitializeVolumeData(
                PartitionHandle,
                &PartitionImage->TotalSectorCount,
                &PartitionImage->NonClusterSectors,
                &PartitionImage->ClusterCount,
                &PartitionImage->SectorsPerCluster
                );

    } else {
        if(NtfsIsNtfs(PartitionHandle)) {
            *FsType = FilesystemNtfs;
            _Log("    The partition is NTFS...\n");
            b = NtfsInitializeVolumeData(
                    PartitionHandle,
                    &PartitionImage->TotalSectorCount,
                    &PartitionImage->NonClusterSectors,
                    &PartitionImage->ClusterCount,
                    &PartitionImage->SectorsPerCluster
                    );
        } else {
            fprintf(stderr,"\n%s\n",textUnsupportedFs);
            _Log("Error: The partition type is unknown!\n");
            b = FALSE;
        }
    }

    if(b) {
        //
        // Get the system id byte
        //
        b = GetPartitionInfoByHandle(
                PartitionHandle,
                &DiskId,
                &PartitionImage->SystemId,
                &dontcare,
                &dontcare
                );

        if(!b) {
            fprintf(stderr,"\n%s\n",textPartOpenError);
            _Log("Error: Failed opening partition!");
        }
        
        _Log("    System Id Byte      = 0x%02x\n",PartitionImage->SystemId);
        _Log("    Total Sector Count  = 0x%08lx\n",PartitionImage->TotalSectorCount);
        _Log("    Non-Cluster Sectors = 0x%08lx\n",PartitionImage->NonClusterSectors);
        _Log("    Cluster Count       = 0x%08lx\n",PartitionImage->ClusterCount);
        _Log("    Sectors Per Cluster = 0x%02x\n",PartitionImage->SectorsPerCluster);

    }
    
    return(b);
}


BOOL
TransferFsStructsToOutput(
    IN HPARTITION PartitionHandle,
    IN UINT       FileHandle,
    IN ULONG      SectorCount
    )

/*++

Routine Description:

    This routine transfers each sector that is not part of a cluster
    to the output file. Such sectors are assumed to start at sector 0
    and run contiguously through a sector passed to this routine as
    a parameter.

Arguments:

    PartitionHandle - supplies handle to partition being imaged.

    FileHandle - supplies file handle for output. It is assumed that
        the file position is correct; no seeking is performed prior
        to data being written to the file.

    SectorCount - supplies the number of sectors to be transferred
        from the partition to the output file.

Return Value:

    Boolean value indicating outcome. If FALSE, the user will have been
    informed.

--*/

{
    BYTE Count;
    ULONG Sector;
    ULONG OriginalCount;
    unsigned Written;

    Sector = 0L;

    if(SectorCount) {
        printf(textTransferringFsStructs,0);
        printf("\r");
        OriginalCount = SectorCount;
    } else {
        OriginalCount = 0;
    }

    while(SectorCount) {

        Count = (SectorCount > 63L) ? (BYTE)63 : (BYTE)SectorCount;

        if(!ReadPartition(PartitionHandle,Sector,Count,IoBuffer)) {
            fprintf(stderr,"\n");
            fprintf(stderr,textReadFailedAtSector,Sector);
            fprintf(stderr,"\n");
            return(FALSE);
        }

        // update checksum
        CheckSum = CRC32Compute( IoBuffer, Count*512, CheckSum);
        BytesCRC += Count * 512;

        if(_dos_write(FileHandle,IoBuffer,Count*512,&Written) || (Written != (Count*512U))) {
            fprintf(stderr,"\n%s\n",textFileWriteError);
            return(FALSE);
        }

        Sector += Count;
        SectorCount -= Count;

        printf(textTransferringFsStructs,100 * (OriginalCount - SectorCount) / OriginalCount);
        printf("\r");
    }

    if(OriginalCount) {
        printf("\n");
    }

    return(TRUE);
}


BOOL
TransferUsedClustersToOutput(
    IN HANDLES         *Handles,
    IN PARTITION_IMAGE *PartitionImage
    )
{
    ULONG StartCluster,ClusterCount;
    ULONG StartSector,SectorCount;
    BYTE Count;
    UINT Written;
    BOOL b;
    ULONG SectorsSoFar;

    printf(textTransferringClusters,0);
    printf("\r");
    SectorsSoFar = 0;

    //
    // Reserve the last sector of the io buffer for the cluster map
    //
    if(!InitClusterMap((FPBYTE)IoBuffer+(62*512),Handles->BitmapFileHandle,PartitionImage->LastUsedCluster)) {
        return(FALSE);
    }

    b = TRUE;
    while(b && (b=GetNextClusterRun(&StartCluster,&ClusterCount)) && ClusterCount) {

        StartSector = PartitionImage->NonClusterSectors
                    + (StartCluster * PartitionImage->SectorsPerCluster);

        SectorCount = ClusterCount * PartitionImage->SectorsPerCluster;

        while(b && SectorCount) {

            Count = (SectorCount > 62L) ? (BYTE)62 : (BYTE)SectorCount;

            if(b = ReadPartition(Handles->SourcePartitionHandle,StartSector,Count,IoBuffer)) {
                if(!_dos_write(Handles->OutputFileHandle,IoBuffer,Count*512,&Written) && (Written == (Count*512U))) {
                    SectorCount -= Count;
                    StartSector += Count;
                    SectorsSoFar += Count;

                    printf(
                        textTransferringClusters,
                        (100*SectorsSoFar) / (PartitionImage->UsedClusterCount*PartitionImage->SectorsPerCluster)
                        );

                    printf("\r");
                    
                    // update checksum
                    CheckSum = CRC32Compute( IoBuffer, Count*512, CheckSum);
                    BytesCRC += Count * 512;

                } else {
                    fprintf(stderr,"\n%s\n",textFileWriteError);
                    b = FALSE;
                }
            } else {
                fprintf(stderr,"\n");
                fprintf(stderr,textReadFailedAtSector,StartSector);
                fprintf(stderr,"\n");
            }
        }
    }

    if(b) {
        printf("\n");
    }

    return(b);
}


BOOL
AppendClusterMapToOutput(
    IN HANDLES         *Handles,
    IN PARTITION_IMAGE *PartitionImage
    )

/*++

Routine Description:

    This routine appends the cluster bitmap file to the end of the
    partition image output file.

Arguments:

    Handles - supplies a pointer to the structure that contains the
        2 output file handles. This routine takes care of seeking, rewinding,
        etc, so no assumptions are made about the handles' state.

    PartitionImage - supplies information about the partition being imaged
        and partition image file being created.

Return Value:

    Boolean value indicating outcome. If FALSE, the user will have been
    informed.

--*/

{
    ULONG BitmapSizeBytes;
    UINT Read,Written;
    ULONG BytesLeft;
    UINT Size;

    printf(textCombiningFiles,0);
    printf("\r");

    //
    // Figure out how large the bitmap actually is in bytes,
    // rounding up to a sector boundary.
    //
    BitmapSizeBytes = ((PartitionImage->LastUsedCluster/(8*512)) + 1) * 512;

    //
    // Seek to the end of the output file and the start of the
    // cluster bitmap file, just in case.
    //
    DosSeek(Handles->OutputFileHandle,0,DOSSEEK_END);
    DosSeek(Handles->BitmapFileHandle,0,DOSSEEK_START);

    //
    // Transfer data.
    //
    BytesLeft = BitmapSizeBytes;

    while(BytesLeft) {

        Size = (BytesLeft > (63*512)) ? 63*512 : (UINT)BytesLeft;

        if(_dos_read(Handles->BitmapFileHandle,IoBuffer,Size,&Read) || (Read != Size)) {
            fprintf(stderr,"\n%s\n",textFileReadFailed);
            return(FALSE);
        }

        CheckSum = CRC32Compute( IoBuffer, Size, CheckSum);
        BytesCRC += Size;

        if(_dos_write(Handles->OutputFileHandle,IoBuffer,Size,&Written) || (Written != Size)) {
            fprintf(stderr,"\n%s\n",textFileWriteError);
            return(FALSE);
        }

        BytesLeft -= Size;

        printf(textCombiningFiles,100 * (BitmapSizeBytes - BytesLeft) / BitmapSizeBytes);
        printf("\r");
    }

    printf("\n");
    return(TRUE);
}