calculate MAC,Lisence,Checksum and generate muti-file

/*************************************************************************
 *    calculate MAC,Lisence,Checksum and generate muti-file
 * 声明：
 *  1. 以升序的方式批量生成MAC地址方法；
 *  2. 以升序、降序的方式批量生成数字形式的Lisence方法；
 *  3. 以累加的方式计算MAC地址、Lisence的Checksum；
 *  4. 不提供源数据处理文件，仅仅是处理数据代码；
 *  5. 本软件主要是为后续软件开发提供更好的解决数据处理的方式。
 *  6. 本人并没有对代码进行优化，主要是考虑到保留编写代码过程中的一些细节。
 *
 *                                   2015-8-24 晴 深圳 南山平山村 曾剑锋
 ************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define debug 

#ifdef debug
    #define Debug(...) fprintf(stdout,"debug: " __VA_ARGS__);
#else
    #define Debug(...)
#endif

int  htoi( char s[] );
int  createDir( const char *sPathName );
int  changeLisenceByte( char * lisenceByte, int number );
void calculateNextMacAddress( int mac[], int i );
void calculateNextLisence( char lisence[], int i );

int main ( int argc, char ** argv ) {

    int  i               = ;
    int  ret             = ;
    int  count           = ;
    int  mac[]          = {};
    char lisence[]     = {};
    FILE *mtd5OutFile    = NULL;
    FILE *mtd6OutFile    = NULL;
    char readBuffer[] = {};

    if ( argc !=  ) {                                    // check arguments number
        printf ( " USAGE:\n" );
        printf ( "     macLis <mac> <lisence> <count>\n" );
        printf ( "     example:\n" );
        printf ( "         macLis 11:22:33:44:55:66 20150609622300214 10   \n" );
        return -;
    }

    printf ( "mac : %s\n", argv[] );
    printf ( "lisence : %s\n", argv[] );
    printf ( "count : %s\n", argv[] );

    for ( i = ; i < ; i++ ) {
        argv[][ ( i +  ) *  - ] = '\0';                // change ':' to '\0'
        mac[i] = htoi ( argv[] + ( i *  ) );
    }
    Debug ( "mac : %2x:%2x:%2x:%2x:%2x:%2x\n", mac[], mac[], mac[], mac[], mac[], mac[] );

    memcpy ( lisence, argv[], sizeof(lisence) -  );
    Debug ( "lisence : %s\n", lisence );

    count = atoi ( argv[] );                            // how many diretory to generate
    Debug ( "count : %d\n", count);

    FILE *mtd5SourceFile = fopen ( "temp5", "rb" );        // open input file with binary
    FILE *mtd6SourceFile = fopen ( "temp6", "rb" );

    char dirPath[]              = {};
    char outMtd5FilePath[]      = {};
    char outMtd6FilePath[]      = {};
    char macString[]            = {};
    long sum                      = ;

    for ( i = ; i < count ; i++ ) {

        sprintf ( dirPath, "%03d", i );                    // generator diretory
        sprintf ( outMtd5FilePath, "%03d/temp5", i );   // generator temp5 file
        sprintf ( outMtd6FilePath, "%03d/temp6", i );   // generator temp6 file

        createDir( dirPath );
        mtd5OutFile = fopen ( outMtd5FilePath, "w+b" );    // open output file with binary
        mtd6OutFile = fopen ( outMtd6FilePath, "w+b" );

        rewind ( mtd5SourceFile );                        // go head
        rewind ( mtd6SourceFile );

        // copy file content
        while ( ret = fread ( readBuffer, , sizeof(readBuffer), mtd5SourceFile ) )
            fwrite ( readBuffer, , sizeof(readBuffer), mtd5OutFile );

        // copy file content
        while ( ret = fread ( readBuffer, , sizeof(readBuffer), mtd6SourceFile ) )
            fwrite ( readBuffer, , sizeof(readBuffer), mtd6OutFile );

        // generate mac string and write to file
        sprintf ( macString, "%c%c%c%c%c%c", mac[], mac[], mac[], mac[], mac[], mac[] );
        fseek(mtd5OutFile, (0x670) + , SEEK_SET);
        fwrite ( macString, , , mtd5OutFile );
        fseek(mtd6OutFile, (0x30) + , SEEK_SET);
        fwrite ( macString, , , mtd6OutFile );

        // write Lisence number to file
        fseek(mtd5OutFile, (0x680) + , SEEK_SET);
        fwrite ( lisence, , , mtd5OutFile );
        fseek(mtd6OutFile, (0x40) + , SEEK_SET);
        fwrite ( lisence, , , mtd6OutFile );

        // clear the data has used
        bzero ( dirPath, sizeof(dirPath) );
        bzero ( outMtd5FilePath, sizeof(outMtd5FilePath) );
        bzero ( outMtd6FilePath, sizeof(outMtd5FilePath) );

        // change MAC address with increase number 1
        calculateNextMacAddress( mac,  );
        // change lisence with decrease number 1
        calculateNextLisence( lisence, - );

            /**
             * go to calculate checksum
             */

            // read check data from file
            bzero ( readBuffer, sizeof(readBuffer) );
            fseek ( mtd5OutFile, (0x640) + 0x0d, SEEK_SET );
            fread ( readBuffer, , *, mtd5OutFile);

            // add all data as checksum, be carefull to use unsigned char to keep data was byte
            int j = ;
            sum = ;
            for ( j = ; j < (  *  ); j++ )
                sum += ( unsigned char ) readBuffer[j];   // must type change to keep is positive
            char checkSum[] = {};
            sprintf ( checkSum, "%04x", sum );
            Debug ( " temp5 checkSum: %s\n", checkSum );

            // write checksum to file
            fseek ( mtd5OutFile, (0x640) + 0x08, SEEK_SET );
            fwrite ( &sum, , , mtd5OutFile);

            bzero ( readBuffer, sizeof(readBuffer) );
            bzero ( checkSum, sizeof(checkSum) );

            // work way as above
            fseek ( mtd6OutFile, (0x000) + 0x09, SEEK_SET );
            fread ( readBuffer, , *, mtd6OutFile);

            sum = ;
            for ( j = ; j < (  *  ); j++ )
                sum += ( unsigned char ) readBuffer[j];   // must type change to keep is positive
            sprintf ( checkSum, "%04x", sum );
            Debug ( " temp6 checkSum: %s\n", checkSum );

            fseek ( mtd6OutFile, (0x000) + 0x04, SEEK_SET );
            fwrite ( &sum, , , mtd6OutFile);

            bzero ( readBuffer, sizeof(readBuffer) );

        // flush to file and close
        fflush ( mtd5OutFile );
        fclose ( mtd5OutFile );

        fflush ( mtd6OutFile );
        fclose ( mtd6OutFile );
    }

    fclose ( mtd5SourceFile );
    fclose ( mtd6SourceFile );

    return ;
}

int htoi(char s[])
{
    int i;
    int n = ; 

    // skip "0x" or "0X"
    if (s[] == '' && (s[]=='x' || s[]=='X')) {
        i = ;
    } else {
        i = ;
    } 

    for (; (s[i] >= '' && s[i] <= '') || (s[i] >= 'a' && s[i] <= 'z') || (s[i] >='A' && s[i] <= 'Z'); ++i) {   

        if (tolower(s[i]) > '') {
            n =  * n + ( + tolower(s[i]) - 'a');
        } else {
            n =  * n + (tolower(s[i]) - '');
        } 

    } 

    return n;
} 

int createDir(const char *sPathName)
{
    char  DirName[];
    int   i;
    int   len = strlen ( DirName );  

    strcpy ( DirName,   sPathName );  

    if ( DirName[ len- ] != '/' )
        strcat ( DirName,   "/" );  

    len = strlen ( DirName );  

    for ( i = ; i < len; i++ ) {
        if ( DirName[i] == '/' ) {
            DirName[i] = ;
            if( access ( DirName, NULL ) !=  ) {
                if(mkdir(DirName, )==-) {
                     perror("mkdir  error");
                    return -;
                }
            }
            DirName[i] = '/';
        }
    }  

    return   ;
}   

/**
 * i: this can only be positive
 */
void calculateNextMacAddress( int mac[], int i ) {

    int macByte5 = ( i + mac[] ) % ;
    int macByte4 = ( ( i + mac[] ) /   + mac[] ) % ;
    int macByte3 = ( ( ( ( i + mac[] ) /  ) + mac[] ) /   + mac[] ) % ;
    int macByte2 = ( ( ( ( ( i + mac[] ) /  ) + mac[] ) /   + mac[] ) /   + mac[] ) % ;
    int macByte1 = ( ( ( ( ( ( i + mac[] ) /  ) + mac[] ) /   + mac[] ) /   + mac[] ) /  + mac[] ) % ;
    int macByte0 = ( ( ( ( ( ( ( i + mac[] ) /  ) + mac[] ) /   + mac[] ) /   + mac[] ) /  + mac[] ) /  + mac[] ) % ;

    mac[] = macByte0;
    mac[] = macByte1;
    mac[] = macByte2;
    mac[] = macByte3;
    mac[] = macByte4;
    mac[] = macByte5;

    Debug ( "calculate next Mac : %02x:%02x:%02x:%02x:%02x:%02x\n", macByte0, macByte1, macByte2, macByte3, macByte4, macByte5 );
}

void calculateNextLisence( char lisence[], int i ) {
    int tmp = ;
    tmp = changeLisenceByte( &lisence[], i );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );
    tmp = changeLisenceByte( &lisence[], tmp );

    Debug ( "calculate next lisence : %s\n", lisence );
}

/**
 * number: this can be positive or negative
 */
int changeLisenceByte( char * lisenceByte, int number ) {
    int tmp = ;
    if ( ( lisenceByte[] -  ) + number <  ) {
        tmp = ( ( lisenceByte[] -  ) + number ) /  - ;
        lisenceByte[] = (  + ( ( lisenceByte[] -  ) + number ) %  ) + ;
    } else {
        tmp = ( ( lisenceByte[] -  ) + number ) / ;
        lisenceByte[] = ( ( lisenceByte[] -  ) + number ) %  + ;
    }

    return tmp;
}