/* (C) 2003-2007 Willem Jan Hengeveld <itsme@xs4all.nl>
 * Web: http://www.xs4all.nl/~itsme/
 *      http://wiki.xda-developers.com/
 *
 * $Id: pgsmdump.cpp 1921 2008-07-31 17:08:31Z itsme $
 */
#include <windows.h>
#include "ItsUtils.h"
#include "dllversion.h"
#include "debug.h"
#include "stringutils.h"
#include "args.h"
#include <stdio.h>
#include <string.h>
#include <rapi.h>

int g_nDumpUnitSize=1;
int g_nMaxWordsPerLine=-1;

bool g_bDoResetGsm= false;
int g_nStepSize= 0;

bool ResetGsm();
void CopyGsmMemoryToFile(DWORD dwOffset, DWORD dwLength, char *szOutfile);
void DumpGsmMemoryToStdout(DWORD dwOffset, DWORD dwLength);
void StepGsmMemoryToStdout(DWORD dwOffset, DWORD dwLength);

void usage()
{
    printf("(C) 2003-2008 Willem jan Hengeveld  itsme@xs4all.nl\n");
    printf("Usage: pgsmdump [-r] [-s step ] start length [ filename ]\n");
    printf("    numbers can be specified as 0x1234abcd\n");
    printf("    -1 -2 -4 : dump as bytes/words/dwords\n");
    printf("    -w NUM : specify nr of words per line\n");
    printf("    -r     : first reset the gsm\n");
    printf("    -s STEP: print NUM words from each STEP size block\n");
}

int main( int argc, char *argv[])
{
    DebugStdOut();

    DWORD dwOffset=0;
    DWORD dwLength=0;
    char *szOutfile=NULL;

    int argsfound=0;
    for (int i=1 ; i<argc ; i++)
    {
        if (argv[i][0]=='-') switch(argv[i][1])
        {
            case 'w': HANDLEULOPTION(g_nMaxWordsPerLine, DWORD); break;

            case '1': case '2': case '4':
                g_nDumpUnitSize= argv[i][1]-'0';
                break;
            case 'r': g_bDoResetGsm= true; break;
            case 's': HANDLEULOPTION(g_nStepSize, DWORD); break;
            default:
                usage();
                return 1;
        }
        else switch (argsfound++)
        {
            case 0: dwOffset= strtoul(argv[i], 0, 0); break;
            case 1: dwLength= strtoul(argv[i], 0, 0); break;
            case 2: szOutfile= argv[i]; break;
        }
    }

    if (argsfound==0 || argsfound>3)
    {
        usage();
        return 1;
    }
    if (argsfound==1)
        dwLength= 0x100;

    if (g_nMaxWordsPerLine<0)
        g_nMaxWordsPerLine= 16/g_nDumpUnitSize;

    CheckITSDll();

    if (g_bDoResetGsm)
        ResetGsm();

    if (g_nStepSize)
        StepGsmMemoryToStdout(dwOffset, dwLength);
    else if (szOutfile==NULL)
        DumpGsmMemoryToStdout(dwOffset, dwLength);
    else
        CopyGsmMemoryToFile(dwOffset, dwLength, szOutfile);

    CeRapiUninit();

    return 0;
}

bool ITReadGsmMemory(DWORD dwOffset, BYTE *buffer, DWORD dwBytesWanted, DWORD *pdwNumberOfBytesRead)
{
    ReadGsmMemoryParams inbuf;
    DWORD outsize=0;
    ReadGsmMemoryResult *outbuf=NULL;

    inbuf.dwOffset= dwOffset;
    inbuf.nSize= dwBytesWanted;
    outbuf= NULL; outsize= 0;
    HRESULT res= ItsutilsInvoke(L"ITReadGsmMemory",
            sizeof(ReadGsmMemoryParams), (BYTE*)&inbuf,
            &outsize, (BYTE**)&outbuf);
    if (res || outbuf==NULL)
    {
        error(res, "ITReadGsmMemory");
        return false;
    }
    memcpy(buffer, &outbuf->buffer, outbuf->dwNumberOfBytesRead);
    *pdwNumberOfBytesRead= outbuf->dwNumberOfBytesRead;
    LocalFree(outbuf);

    return true;
}

void StepGsmMemoryToStdout(DWORD dwOffset, DWORD dwLength)
{
    while (dwLength)
    {
        BYTE buffer[32768]; // assuming 32768 >= g_nDumpUnitSize*g_nMaxWordsPerLine
        DWORD dwNumberOfBytesRead;
        if (ITReadGsmMemory(dwOffset, buffer, min(dwLength, g_nDumpUnitSize*g_nMaxWordsPerLine), &dwNumberOfBytesRead))
            debug("%hs\n", hexdump(dwOffset, buffer, dwNumberOfBytesRead, g_nDumpUnitSize, g_nMaxWordsPerLine).c_str());
        else
            debug("%08lx: -----\n", dwOffset);

        dwLength -= min(dwLength, g_nStepSize);
        dwOffset += min(dwLength, g_nStepSize);
    }
}
void DumpGsmMemoryToStdout(DWORD dwOffset, DWORD dwLength)
{
    while (dwLength)
    {
        BYTE buffer[32768];
        DWORD dwNumberOfBytesRead;
        if (!ITReadGsmMemory(dwOffset, buffer, min(dwLength, 32768), &dwNumberOfBytesRead))
            return;
        
        debug("%hs\n", hexdump(dwOffset, buffer, dwNumberOfBytesRead, g_nDumpUnitSize, g_nMaxWordsPerLine).c_str());

        dwLength -= dwNumberOfBytesRead;
        dwOffset += dwNumberOfBytesRead;
    }
}
void CopyGsmMemoryToFile(DWORD dwOffset, DWORD dwLength, char *szOutfile)
{
    debug("CopyGsmMemoryToFile(%08lx, %08lx, %s)\n",
            dwOffset, dwLength, szOutfile);
    HANDLE hDest = CreateFile( szOutfile, GENERIC_WRITE, FILE_SHARE_READ,
                NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (INVALID_HANDLE_VALUE == hDest)
    {
        error("Unable to open host/destination file");
        return;
    }

    while (dwLength)
    {
        BYTE buffer[32768];
        DWORD dwNumberOfBytesRead;
        if (!ITReadGsmMemory(dwOffset, buffer, min(dwLength, 32768), &dwNumberOfBytesRead))
            return;

        DWORD dwNumWritten;
        if (!WriteFile(hDest, buffer, dwNumberOfBytesRead, &dwNumWritten, NULL))
        {
            error("Error Writing file");
            return;
        }

        dwLength -= dwNumberOfBytesRead;
        dwOffset += dwNumberOfBytesRead;
    }
    CloseHandle (hDest);
}

bool ResetGsm()
{
    GsmControlParams inbuf;
    DWORD outsize=0;
    GsmControlResult *outbuf=NULL;

    inbuf.nCmd = GSM_RESET;
    outbuf= NULL; outsize= 0;
    HRESULT res= ItsutilsInvoke(L"ITGsmControl",
            sizeof(GsmControlParams), (BYTE*)&inbuf,
            &outsize, (BYTE**)&outbuf);
    if (res || outbuf==NULL)
    {
        error(res, "ITGsmControl");
        return false;
    }
    LocalFree(outbuf);

    return true;
}