/*
    $Workfile:    Crypt.C    $
    $Revision:    v1.2    $
    $Date:     04/17/2007 23:14:55    $
*/

/*******************************************************************************
// I N C L U D E    F I L E S
/******************************************************************************/
#include <stdio.h>
#include <string.h>

/*******************************************************************************
// M A C R O    D E F I N I T I O N S
/******************************************************************************/
/* Debug */
#define DEBUG_PRINTFx

#ifdef DEBUG_PRINTF
    #define debug_printf        printf
#else
    #define debug_printf(s, a)
#endif

/* Version */
#define CURRENT_VERSION     "v1.2"
#define M                   (1024L*1024L)
/* String */
#define PARAM_DFT   ""
#define KEY_DFT     "crypt"
#define LOG_FILE    KEY_DFT##".log"
#define EXE_FILE    KEY_DFT##".exe"

/* Conststant */
#define SIZE_ONE_BYTE   1
#define COUNT_ONE       1

/*******************************************************************************
//  E N U M E R A T I O N    D E F I N I T I O N S
/******************************************************************************/
typedef enum encrypt_mode
{
    MODE_EnCode,
    MODE_DeCode,
    MODE_Help,
    
}Em_EncryptMode;

typedef enum err_ret
{
    ERR_NONE,
    
    ERR_cpName,
    ERR_cpParams,
    ERR_cpFile,
    ERR_cpKey,
    
    ERR_Params,
    ERR_FOpen,
    ERR_FRead,
    ERR_FWrite,
    
} Em_ErrRet;

/*******************************************************************************
// F U N C T I O N    P R O T O T Y P E S
/******************************************************************************/
unsigned long flen(FILE *fp_file);
unsigned char ParamsParse(char *cpParams);
int CheckArgv(char *cpName, char *cpParams, char *cpFile, char *cpKey);
int ByteCryptFile(unsigned int uiMode, char *cpFile, char *cpKey);
int WriteToLogFile(char *cpName, char *cpParams, char *cpFile, char *cpKey);
void PrintVersion(void);
void PrintHelpInfo(void);

/*******************************************************************************
//  C O D E S
/******************************************************************************/

/*******************************************************************************
//
// Function    :    main
// Params      :    int argc, char *argv[]
//                  
// Returns     :    int
// Global      :    None
// Description :
//
/******************************************************************************/
int main(int argc, char *argv[])
{
    int iRet;
    char *cpName, *cpParams, *cpFile, *cpKey;     /* Arguments */
    
    /* Print version */
    PrintVersion();
    
    /* Program arguments parse */
    cpName = argv[0];
    if (argc == 0)
    {}
    else if (argc == 4)
    { cpParams = argv[1];    cpFile = argv[2];     cpKey = argv[3]; }
    else if (argc == 3)
    { cpParams = argv[1];    cpFile = argv[2];     cpKey = KEY_DFT; }
    else if (argc == 2)
    { cpParams = argv[1];    cpFile = "";          cpKey = ""; }
    else if (argc == 1)
    { cpParams = "";         cpFile = "";          cpKey = ""; }
    else
    {}
    
    debug_printf("cpName = %s  \n", cpName);
    debug_printf("cpParams = %s  \n", cpParams);
    debug_printf("cpFile = %s  \n", cpFile);
    debug_printf("cpKey = %s  \n", cpKey);

    {
        unsigned int uiMode;
        uiMode = ParamsParse(cpParams);
        switch (uiMode)
        {
            case MODE_Help:
            {
                PrintHelpInfo();
                iRet = ERR_NONE;
                break;
            }
            case MODE_EnCode:
            case MODE_DeCode:
            {
                iRet = CheckArgv(cpName, cpParams, cpFile, cpKey);
                if (!iRet)
                {
                    iRet = ByteCryptFile(uiMode, cpFile, cpKey);
                    if (!iRet)
                    {
                        iRet = WriteToLogFile(cpName, cpParams, cpFile, cpKey);
                    }
                }
                break;
            }
            default:
            {
                printf("unknown params. \n");
                iRet = ERR_Params;
                break;
            }
        }
    }
    if (!iRet)
    {
        printf(":) Successful !", 0);
    }
    else
    {
        printf(":( Failed ?", 0);
    }
    return iRet;
}

/*******************************************************************************
//
// Function    :    PrintVersion
// Params      :    void
// Returns     :    void
// Global      :    None
// Description :    
//
/******************************************************************************/
void PrintVersion(void)
{
    printf("%s %s \n", EXE_FILE, CURRENT_VERSION);
}

/*******************************************************************************
//
// Function    :    PrintHelpInfo
// Params      :    void
// Returns     :    void
// Global      :    None
// Description :    
//
/******************************************************************************/
void PrintHelpInfo(void)
{
    printf("The comand line is like this: \n");
    printf("command line: \n");
    printf("    crypt [cpParams] [cpFile] [cpKey] \n");
    printf("arguments description: \n");
    printf("    cpParams :  /E|/e == Encode; \n");
    printf("                /D|/d == Decode; \n");
    printf("                /?    == help information; \n");
    printf("                else  == unknown params. \n");
    printf("    cpFile   :  file which needed Encode or Decode \n");
    printf("    cpKey    :  key which used for Encoding or Decoding \n");
    printf("");
}

/*******************************************************************************
//
// Function    :    ParamsParse
// Params      :    char *cpParams
//
// Returns     :    unsigned char : MODE_EnCode == indicate encode mode;
//                                  MODE_DeCode == indicate decode mode;
//                                  else        == indicate invalid mode.
// Global      :    None
// Description :    
//
/******************************************************************************/
unsigned char ParamsParse(char *cpParams)
{
    unsigned char ucRet = 0xFF;

    if (*cpParams == '/')
    {
        ++cpParams;
        switch (*cpParams)
        {
            case 'E': case 'e':
                ucRet = MODE_EnCode;
                break;
            case 'D': case 'd':
                ucRet = MODE_DeCode;
                break;
            case '?':
                ucRet = MODE_Help;
                break;
        }
    }

    return ucRet;
}

/*******************************************************************************
//
// Function    :    flen
// Params      :    FILE *fp_file
//
// Returns     :    unsigned long
// Global      :    None
// Description :    
//
/******************************************************************************/
unsigned long flen(FILE *fp_file)
{
    unsigned long ulCur, ulLen;
    
    ulCur = ftell(fp_file);

    fseek(fp_file, 0L, SEEK_END);
    ulLen = ftell(fp_file);

    fseek(fp_file, ulCur, SEEK_SET);

    return ulLen;
}

/*******************************************************************************
//
// Function    :    CheckArgv
// Params      :    char *cpName, char *cpParams, char *cpFile, char *cpKey
//
// Returns     :    int : 0    == indicate successfully;
//                        else == indicate hava error occured.
// Global      :    None
// Description :    Check argv is valid or not
//
/******************************************************************************/
int CheckArgv(char *cpName, char *cpParams, char *cpFile, char *cpKey)
{
    int iRet = ERR_NONE;

    /* cpName checking... */
    if ((cpName == NULL) || (*cpName) == 0)
    {
        iRet = ERR_cpName;
        printf("cpName(NULL) or *cpName(0)  \n", 0);
    }
    /* cpParams checking... */
    else if ((cpParams == NULL) || (*cpParams) == 0)
    {
        iRet = ERR_cpParams;
        printf("cpParams(NULL) or *cpParams(0)  \n", 0);
    }
    /* cpFile checking... */
    else if ((cpFile == NULL) || (*cpFile) == 0)
    {
        iRet = ERR_cpFile;
        printf("cpFile(NULL) or *cpFile(0)  \n", 0);
    }
    /* cpKey checking... */
    else if ((cpKey == NULL) || (*cpKey) == 0)
    {
        iRet = ERR_cpKey;
        printf("cpKey(NULL) or *cpKey(0)  \n", 0);
    }

    return iRet;
}

/*******************************************************************************
//
// Function    :    ByteCryptFile
// Params      :    char *cpName, char *cpParams, char *cpFile, char *cpKey
//
// Returns     :    int : 0    == indicate successfully;
//                        else == indicate hava error occured.
// Global      :    None
// Description :
//
/******************************************************************************/
int ByteCryptFile(unsigned int uiMode, char *cpFile, char *cpKey)
{
    int iRet = ERR_NONE;

    FILE *fpRead, *fpWrite;

    fpWrite = fpRead = fopen(cpFile, "rb+");
    /* fpWrite checking... */
    if ((fpWrite == NULL))
    {
        iRet = ERR_FOpen;
        printf("can't open file cpFile(%s)  \n", cpFile);
    }
    else
    {
        unsigned char ucBuff, ucKey;
        unsigned long ulCur, ulLen;
        unsigned int uiIndex;
        
        ulLen = flen(fpRead);
        debug_printf("cpFile(%s) 's length ", cpFile);
        debug_printf(": 0x%x  \n", (unsigned long)ulLen);

        uiIndex = 0;
        /* only process 1M bytes data */
        if (ulLen > 1 * M) ulLen = 1 * M;
            
        for (ulCur = 0; ulCur < ulLen; ulCur++)
        {
            fseek(fpRead, ulCur, SEEK_SET);
            /* read checking... */
            if (fread(&ucBuff, SIZE_ONE_BYTE, COUNT_ONE, fpRead) != COUNT_ONE)
            {
                iRet = ERR_FRead;
                printf("cpFile(%s) fread error!  \n", cpFile);
                break;
            }

            /* key loop */
            uiIndex = (uiIndex < strlen(cpKey)) ? uiIndex+1 : 0;
            ucKey = *(cpKey + uiIndex);
            /* byte crypt */
            if (ucBuff != 0)    
            {    /* ignore 0 because of the key maybe known by hex display */
                ucBuff = (uiMode == MODE_EnCode) ? (unsigned char)(ucBuff + ucKey) :
                         (uiMode == MODE_DeCode) ? (unsigned char)(ucBuff - ucKey) :
                                                   (unsigned char)(ucBuff ^ 0)     ;
            }
            fseek(fpRead, ulCur, SEEK_SET);
            /* write checking... */
            if (fwrite(&ucBuff, SIZE_ONE_BYTE, COUNT_ONE, fpWrite) != COUNT_ONE)
            {
                iRet = ERR_FWrite;
                printf("cpFile(%s) fwrite error!  \n", cpFile);
                break;
            }
            
            debug_printf("crypting...0x%x \r", (unsigned long)ulCur);
        }
        debug_printf("crypting...0x%x \n", (unsigned long)ulCur);

        fclose(fpWrite);
        fclose(fpRead);
    }

    debug_printf("ByteCryptFile : iRet = %d  \n", iRet);
    return iRet;
}

/*******************************************************************************
//
// Function    :    WriteToLogFile
// Params      :    char *cpName, char *cpParams, char *cpFile, char *cpKey
//
// Returns     :    int : 0    == indicate successfully;
//                        else == indicate hava error occured.
// Global      :    None
// Description :    Write information to the log file
//
/******************************************************************************/
int WriteToLogFile(char *cpName, char *cpParams, char *cpFile, char *cpKey)
{
    int iRet = ERR_NONE;

    FILE *fpWrite;

    fpWrite = fopen(LOG_FILE, "a+");
    /* fpWrite checking... */
    if ((fpWrite == NULL))
    {
        iRet = ERR_FOpen;        /* can't open file */
        printf("can't open file cpFile(%s)  \n", cpFile);
    }
    else
    {
        fprintf(fpWrite, "%s\t%s\t%s\t%d\n", cpName, cpParams, cpFile, strlen(cpKey));
        fclose(fpWrite);
    }

    debug_printf("cpName = %s  \n", cpName);
    debug_printf("cpParams = %s  \n", cpParams);
    debug_printf("cpFile = %s  \n", cpFile);
    debug_printf("cpKey = %s  \n", cpKey);

    debug_printf("WriteToLogFile : iRet = %d  \n", iRet);
    return iRet;
}