mtkdump.cpp

DVD

	}
	return firstnonoption;
}

// **********************************************************************
//  READ FILE TO BUFFER
// **********************************************************************

int ReadFileToBuf(char filename[255], char **ptrBuf)
{
	FILE *fi;
	long length;

	// Open file
	fi = fopen(filename, "rb");
	if (fi==NULL)
	{
		printf("- Failed to open input file '%s'\n", filename);
		return -1;
	}

	// Get length
	fseek(fi, 0, SEEK_END);
	length = ftell(fi);
	fseek(fi, 0, SEEK_SET);
	if (length>0xFFFFF)
	{
		printf("- Input file is way too big '%s'\n", filename);
		return -1;
	}

	// Try free buf
	if(*ptrBuf != NULL) free(*ptrBuf);

	// Allocate memory for file
	*ptrBuf = (char *) malloc(length);
	if (*ptrBuf==NULL)
	{
		printf("- Failed to allocate memory for '%s'\n", filename);
		return -1;
	}

	// Read file to buf
	printf(" + Reading.. '%s'\n", filename);
	fread(*ptrBuf, 1, length, fi);
	fclose(fi);

	return (int) length;
}

// **********************************************************************
//  READ FROM MEMORY
// **********************************************************************

int DumpRead(char filename[255])
{
    FILE    *file;
    uchar   *pszBuffer;  							// Temp buffer for in file

    int     iRet;
    ulong   ulBytesRead;
    ulong   ulAddress;
    ulong   ulLength;
    uchar   bTarget;
    TMediatek *MtkCom;
    int     jooo;

  #ifdef THREAD
    HANDLE  Thread;
    stThreadParam ThreadParam;
  #endif

//  double dTickRatio;
//  int iTickCount;

	try
	{
        if(iDumpLength == -1)
        {
            // Error no read or write selected
            printf("- No read length set (/l=LONG)\n");
            return EXIT_FAILURE;
        }

        // Open output file
        file = fopen(filename, "wb");
        if (file == NULL)
        {
            printf("- Failed to open output file '%s'\n", filename);
            return EXIT_FAILURE;
        }

        // Convert address from int to ulong
        ulAddress = (ulong) iDumpAddress;
        ulLength  = (ulong) iDumpLength;
        bTarget = bDumpTargetMem;

        printf("\nSTART MEMORY DUMP READ\n");
        printf("----------------------\n");
        printf("ADDRESS : 0x%X\n",     ulAddress);
        printf("LENGTH  : %d bytes\n", ulLength);
        printf("TARGET  : %d\n",       bTarget);
        printf("OUTPUT  : %s\n",       filename);

        // Create Mediatek COM
        MtkCom = new TMediatek(); // ComPort->Create();
        MtkCom->SetComPort(bDumpPort,ulDumpBaud,bDumpDataBit,cDumpParity,bDumpStopBit);

        printf("\nCOMMUNICATION \n");
        printf("----------------------\n");
        printf("PORT    : COM%i\n",    bDumpPort);
        printf("BAUD    : %i\n",       ulDumpBaud);
        printf("DATA    : %i\n",       bDumpDataBit);
        printf("PARITY  : %c\n",       mParity(cDumpParity));
        printf("STOP    : %.1f\n",     mStopBit(bDumpStopBit));

        // Set Mediatek COM delay and retry
        MtkCom->SetComRetry(bDumpRetry, bDumpDelay);

        printf("----------------------\n");
        printf("RETRY   : %i\n",       bDumpRetry);
        printf("DELAY   : %i\n",       bDumpDelay);
        printf("\n");


    // *********************************
    //  START DUMPING
    // *********************************

		// Print main log
        printf("------------------------------------------\n");
		printf("MEMDUMP -->\n");
        printf("------------------------------------------\n");

        ulBytesRead = ulLength;

#ifdef THREAD
        ThreadParam.This = MtkCom;
        ThreadParam.bTargetMem = bTarget;
        ThreadParam.ulAddress = ulAddress;
        ThreadParam.ulLength = &ulBytesRead;
        ThreadParam.ptrBuffer = &pszBuffer;

        Thread = (HANDLE) _beginthread(StartRead, 0, &ThreadParam);

        while(WaitForSingleObject( Thread, 75L ) == WAIT_TIMEOUT)
        {
            printf("\rProgress : %i / Time : %i s / Speed : %.2f", (int)(MtkCom->Progress * 100), (MtkCom->ElapsedTime / 1000),  (ulLength * MtkCom->Progress)/(1+MtkCom->ElapsedTime));
            Sleep(100);
        }

        printf("\n");
        iRet = MtkCom->Error;
#else
        iRet = MtkCom->ReadMemory(ulAddress, ulBytesRead, bTarget, &pszBuffer);
#endif
        // Convert Mediatek return value to EXIT
        if(iRet == MEDIATEK_RET_TRUE)
        {
            iRet = EXIT_SUCCESS;
        }
        else
        {
            iRet = EXIT_FAILURE;
        }

        // Close port
        delete MtkCom;

        // Write to output file
        fwrite(pszBuffer, 1, ulBytesRead, file);

		// Close output file
		fclose(file);

		// Print length
		printf("- Memdump %d of %d bytes\n", ulBytesRead, ulLength);

		// Print main log
        printf("------------------------------------------\n");
		printf("<-- MEMDUMP\n");
        printf("------------------------------------------\n");
	}

	catch(char *Text)
	{
		printf("ERROR : %s\n", Text);

		// Close output file
		if (file != NULL)
			fclose(file);

        // Close Port
        delete (MtkCom);
        return EXIT_FAILURE;
	}

	catch(...)
	{
		printf("ERROR : Can't start memory dump");

		// Close output file
		if (file != NULL)
			fclose(file);

        // Close Port
        delete (MtkCom);
        return EXIT_FAILURE;
	}

    return iRet;
}

// **********************************************************************
//  WRITE TO MEMORY
// **********************************************************************

int DumpWrite(char filename[255])
{
	char *ptrBuf;  							// Temp buffer for in file
    iDumpLength = ReadFileToBuf(filename, &ptrBuf);

    if(iDumpLength <= 0)
        return EXIT_FAILURE;

    return EXIT_SUCCESS;
}

// **********************************************************************
//  BACKUP FLASH
// **********************************************************************

int FlashRead(char filename[255])
{
    FILE *file;
    uchar *pszBuffer;  							// Temp buffer for in file

    int   iRet;
    ulong ulBytesRead;
    ulong ulAddress;
    ulong ulLength;
    uchar bTarget;
    TMediatek *MtkCom;

//  double dTickRatio;
//  int iTickCount;

    try
    {
        if(iDumpLength == -1)
        {
            // Error no read or write selected
            printf("- No read length set (/l=LONG)\n");
            return EXIT_FAILURE;
        }

        // Open output file
        file = fopen(filename, "wb");
        if (file == NULL)
        {
            printf("- Failed to open output file '%s'\n", filename);
            return EXIT_FAILURE;
        }

        // Convert address from int to ulong
        ulAddress = (ulong) iDumpAddress;
        ulLength  = (ulong) iDumpLength;
        bTarget = bDumpTargetMem;

        printf("\nSTART FLASH READ\n");
        printf("----------------------\n");
        printf("ADDRESS : 0x%X\n",     ulAddress);
        printf("LENGTH  : %d bytes\n", ulLength);
        printf("TARGET  : %d\n",       bTarget);
        printf("OUTPUT  : %s\n",       filename);

        // Create Mediatek COM
        MtkCom = new TMediatek(); // ComPort->Create();
        MtkCom->SetComPort(bDumpPort,ulDumpBaud,bDumpDataBit,cDumpParity,bDumpStopBit);

        printf("\nCOMMUNICATION \n");
        printf("----------------------\n");
        printf("PORT    : COM%i\n",    bDumpPort);
        printf("BAUD    : %i\n",       ulDumpBaud);
        printf("DATA    : %i\n",       bDumpDataBit);
        printf("PARITY  : %c\n",       mParity(cDumpParity));
        printf("STOP    : %.1f\n",     mStopBit(bDumpStopBit));

        // Set Mediatek COM delay and retry
        MtkCom->SetComRetry(bDumpRetry, bDumpDelay);

        printf("----------------------\n");
        printf("RETRY   : %i\n",       bDumpRetry);
        printf("DELAY   : %i\n",       bDumpDelay);
        printf("\n");

    // *********************************
    //  START FLASH BACKUP
    // *********************************

		// Print main log
        printf("------------------------------------------\n");
		printf("BACKUP -->\n");
        printf("------------------------------------------\n");

        ulBytesRead = ulLength;
        iRet = MtkCom->ReadFlash(ulAddress, ulBytesRead, &pszBuffer);

        // Convert Mediatek return value to EXIT
        if(iRet == MEDIATEK_RET_TRUE)
        {
            iRet = EXIT_SUCCESS;
        }
        else
        {
            iRet = EXIT_FAILURE;
        }

        // Close port
        delete MtkCom;

        // Write to output file
        fwrite(pszBuffer, 1, ulBytesRead, file);

		// Close output file
		fclose(file);

		// Print length
		printf("- Backup %d of %d bytes\n", ulBytesRead, ulLength);

		// Print main log
        printf("------------------------------------------\n");
		printf("<-- BACKUP\n");
        printf("------------------------------------------\n");
	}

	catch(char *Text)
	{
		printf("ERROR : %s\n", Text);

		// Close output file
		if (file != NULL)
			fclose(file);

        // Close Port
        delete (MtkCom);
        return EXIT_FAILURE;
	}

	catch(...)
	{
		printf("ERROR : Can't start flash backup");

		// Close output file
		if (file != NULL)
			fclose(file);

        // Close Port
        delete (MtkCom);
        return EXIT_FAILURE;
	}

    return iRet;
}

// **********************************************************************
//  MAIN
// **********************************************************************

int main(int argc,char *argv[])
{
    char filename[255];           			// File pointers
    int iRet;

	printf("MTK Memory Dumper v0.1b\n");
	printf("Copyright (c) MaBreaker 2006\n\n");

	if (argc == 1)
	{
		// If no arguments we call the Usage routine and exit
		Usage(argv[0]);
		return EXIT_FAILURE;
	}

    // Init default values
    Init();

	// Handle the program options
	iRet = HandleOptions(argc,argv);

    if(iRet <= 0)
    {
        // File defined
        fprintf(stderr,"- No input / output file\n");
        return EXIT_FAILURE;
    }

    // Check dump mode
    if((bDumpRead == false) && (bDumpWrite == false))
    {
        // Error no read or write selected
        fprintf(stderr,"No read or write mode set(/r or /w)\n");
        return EXIT_FAILURE;
    }

    // Check dump filename
    if(strlen(argv[iRet]) >= 255)
    {
        fprintf(stderr,"- Too long filename %s\n", argv[iRet]);
		return EXIT_FAILURE;
    }

    strcpy(filename, argv[iRet]);

    // Check dump address
    if(iDumpAddress == -1)
    {
        fprintf(stderr,"- Address is not set (/a)\n");
		return EXIT_FAILURE;
    }

    // Check dump target memeory
    if((bDumpTargetMem == TARGET_NULL) || (bDumpTargetMem >= TARGET_END))
    {
        fprintf(stderr,"- Target mem not set (/m)\n");
		return EXIT_FAILURE;
    }

    // Start dump
    if (bDumpRead)
    {
        if(bDumpTargetMem == TARGET_FLASH)
        {
            iRet = FlashRead(filename);
        }
        else
        {
            iRet = DumpRead(filename);
        }
    }
    else if (bDumpWrite)
    {
        iRet = DumpWrite(filename);
    }
    else
    {
        // Newer happens
    }

    printf("------------------------------------------\n");
    if(iRet != EXIT_SUCCESS)
    {
		printf("Dump FAILED !!!\n");
		iRet = EXIT_FAILURE;
    }
    else
    {
    	printf("Dump success !\n");
    }
    printf("------------------------------------------\n");

	return iRet;
}