ymodem_main.cpp

Go to the documentation of this file.

/*
This program is distributed under the terms of the 'MIT license'. The text
of this licence follows...

Copyright (c) 2006,2007 J.D.Medhurst (a.k.a. Tixy)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#include "../../common/common.h"
#include "../ymodem_tx.h"
#include "../ymodem_rx.h"


#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>


#ifdef LINUX
#define DEFAULT_PORT 0                          
#else
#define DEFAULT_PORT 1
#endif
#define DEFAULT_BAUD 115200                     
#define DEFAULT_TIMEOUT 30                      
#define DEFAULT_LOG_TIMEOUT 10                  
#define MAX_LOG_END_STRING_LENGTH 128           
const char* ProgramName;                        
unsigned PortNum = DEFAULT_PORT;                
unsigned PortBaud = DEFAULT_BAUD;               
unsigned Timeout = DEFAULT_TIMEOUT*1000;        
bool XModemFlag = false;                        
bool CrcFlag = false;                           
bool KModeFlag = false;
bool GModeFlag = false;                         
bool SendFlag = false;                          
bool ReceiveFlag = false;                       
const char* FileName = 0;                       
const char* DstFileName = 0;                    
const char* LogFileName = 0;                    
unsigned LogTimeout = DEFAULT_LOG_TIMEOUT*1000; 
const char* LogEndString = 0;                   
size_t LogEndStringLength = 0;                  
bool LogEcho = false;                           
enum Error
    {
    ErrorNoMemory       = -500,                 
    ErrorLogFileError   = -501                  
    };

#define STRINGIFY2(a) #a                        
#define STRINGIFY(a) STRINGIFY2(a)              
void Help()
    {
    printf( "Usage: %s [OPTION]... FILE [DST-FILE]\n"
            "Tranfer a file using X-Modem or Y-Modem protocols\n\n"
            "  -s[y|x|k]       Send file.\n"
            "                  If 'y' is specifieied Y-Modem protocol is used. (Default)\n"
            "                  If 'x' is specifieied X-Modem protocol is used.\n"
            "                  If 'k' is specifieied X-Modem 1K protocol is used.\n"
            "  -r[y|g|x|c]     Receive file.\n"
            "                  If 'y' is specifieied Y-Modem protocol is used. (Default)\n"
            "                  If 'g' is specifieied Y-Modem G protocol is used.\n"
            "                  If 'x' is specifieied X-Modem protocol is used.\n"
            "                  If 'c' is specifieied X-Modem CRC protocol is used.\n"
            "  -pPORT          Use communications port PORT. Default is " STRINGIFY(DEFAULT_PORT) "\n"
            "  -bBAUD          Set baud rate for port to BAUD. Default is " STRINGIFY(DEFAULT_BAUD) "\n"
            "  -tTIMEOUT       Set timeout for transfer start (in seconds). Default is " STRINGIFY(DEFAULT_TIMEOUT) "\n"
            "  -lfLOG          Capture log after transfer and write it to file LOG\n"
            "  -le             Echo the captured log to STDOUT.\n"
            "  -ltLOGTIMEOUT   Timeout for log capture (in seconds). Default is " STRINGIFY(DEFAULT_LOG_TIMEOUT) "\n"
            "  -lxSTRING       End log capture when STRING is received\n"
            "\n"
            "FILE is optional when receiving a file by Y-Modem: options -ry or -rg\n"
            "DST-FILE is the name sent to receiver when using Y-Modem. Default is FILE.\n"
            ,ProgramName
            );
    exit(1);
    }


void UsageError(const char *format, ...)
    {
    va_list args;
    va_start(args,format);
    vfprintf(stderr,format,args);
    va_end(args);
    fprintf(stderr,"\nTry '%s -h' for more information.\n",ProgramName);
    exit(1);
    }


void Error(int error,const char *format, ...)
    {
    va_list args;
    va_start(args,format);
    vfprintf(stderr,format,args);
    va_end(args);
    if(error<0)
        fprintf(stderr,". Error %d",error);
    fprintf(stderr,"\n");
    exit(error);
    }


bool GetIntArg(const char* argStr, unsigned& arg)
    {
    char* argEnd;
    unsigned long val = strtoul(argStr,&argEnd,10);
    if(*argEnd)
        return false;
    arg = (unsigned)val;
    return true;
    }


bool GetTimeoutArg(const char* argStr, unsigned& arg)
    {
    if(!GetIntArg(argStr,arg))
        return false;
    // convert to milliseconds...
    if(arg<(~(unsigned)0)/1000u)
        arg *= 1000;
    else
        arg = ~(unsigned)0;
    return true;
    }


void ParseArgs(int argc, char** argv)
    {
    ProgramName = *argv;

    // parse arguments...
    while(--argc)
        {
        char* arg = *++argv;
        if(arg[0]=='"')
            {
            // remove "" from around argument...
            int len = strlen(arg);
            if(arg[len-1]=='"')
                {
                arg[len-1] = 0;
                ++arg;
                *argv = arg;
                }
            }
        if(arg[0]!='-')
            {
            // arg doesn't start with '-' so it must be the name of the file...
            if(DstFileName)
                UsageError("Too many file arguments");
            if(FileName)
                DstFileName = arg;
            else
                FileName = arg;
            continue;
            }

        ++arg; // skip initial '-'
        switch(*arg++)
            {
            case 'p':
                if(!GetIntArg(arg,PortNum))
                    UsageError("Invalid PORT argument");
                break;

            case 'b':
                if(!GetIntArg(arg,PortBaud))
                    UsageError("Invalid BAUD argument");
                break;

            case 't':
                if(!GetTimeoutArg(arg,Timeout))
                    UsageError("Invalid TIMEOUT argument");
                break;

            case 'h':
                Help();

            case 's':
                SendFlag = true;
                XModemFlag = false;
                if(arg[0]!=0)
                    {
                    if(arg[1]!=0)
                        goto invalid;
                    if(arg[0]=='y')
                        ; // default
                    else if(arg[0]=='x')
                        XModemFlag = true, KModeFlag = false;
                    else if(arg[0]=='k')
                        XModemFlag = true, KModeFlag = true;
                    else
                        goto invalid;
                    }
                break;

            case 'r':
                ReceiveFlag = true;
                XModemFlag = false;
                GModeFlag = false;
                if(arg[0]!=0)
                    {
                    if(arg[1]!=0)
                        goto invalid;
                    if(arg[0]=='y')
                        ; // default
                    else if(arg[0]=='g')
                        GModeFlag = true;
                    else if(arg[0]=='x')
                        CrcFlag = false, XModemFlag = true;
                    else if(arg[0]=='c')
                        CrcFlag = true, XModemFlag = true;
                    else
                        goto invalid;
                    }
                break;

            case 'l':
                switch(*arg++)
                    {
                    case 'f':
                        LogFileName = arg;
                        break;
                    case 'e':
                        LogEcho = true;
                        break;
                    case 't':
                        if(!GetTimeoutArg(arg,LogTimeout))
                            UsageError("Invalid LOGTIMEOUT argument");
                        break;
                    case 'x':
                        LogEndStringLength = strlen(arg);
                        LogEndString = arg;
                        if(LogEndStringLength>MAX_LOG_END_STRING_LENGTH)
                            UsageError("String too long in -lx option. Max length is " STRINGIFY(MAX_LOG_END_STRING_LENGTH) );
                        break;
                    default:
                        goto invalid;
                    }
                break;

            default:
                goto invalid;
            }
        continue;
        }
    return;

invalid:
    UsageError("Invalid option '%s'",*argv);
    }


class InFile : public YModemTx::InStream
    {
public:
    InFile()
        : File(0)
        {
        }

    int Open(const char* fileName)
        {
        File = fopen(fileName,"rb");
        if(!File)
            return YModemTx::ErrorInputStreamError;
        // find file size...
        if(fseek(File,0,SEEK_END))
            {
            fclose(File);
            return YModemTx::ErrorInputStreamError;
            }
        TotalSize = ftell(File);
        if(fseek(File,0,SEEK_SET))
            {
            fclose(File);
            return YModemTx::ErrorInputStreamError;
            }
        TransferredSize = 0;
        return 0;
        }

    void Close()
        {
        if(File)
            {
            fclose(File);
            File = 0;
            }
        }

    inline size_t Size()
        {
        return TotalSize;
        }

    int In(uint8_t* data, size_t size)
        {
        int percent = TotalSize ? ((uint64_t)TransferredSize*(uint64_t)100)/(uint64_t)TotalSize : 0;
        printf("%8d bytes of %d - %3d%%\r",TransferredSize, TotalSize, percent);
        fflush(stdout);
        size=fread(data,sizeof(uint8_t),size,File);
        if(size)
            {
            TransferredSize += size;
            return size;
            }
        if(TransferredSize!=TotalSize)
            return YModemTx::ErrorInputStreamError;
        return 0;
        }
private:
    FILE* File;
    size_t TotalSize;
    size_t TransferredSize;
    };


class OutFile : public YModemRx::OutStream
    {
public:
    OutFile()
        : File(0)
        {
        }

    int Open(const char* fileName, size_t size)
        {
        if(File)
            {
            if(TransferredSize)
                return YModemRx::ErrorOutputStreamError;
            }
        else
            {
            File = fopen(fileName,"w+b");
            if(!File)
                return YModemRx::ErrorOutputStreamError;
            printf("Receiving %s...\n",fileName);
            }
        TotalSize = size;
        TransferredSize = 0;
        return 0;
        }

    void Close()
        {
        if(File)
            {
            fclose(File);
            File = 0;
            }
        }

    int Out(const uint8_t* data, size_t size)
        {
        if(!File)
            return YModemRx::ErrorOutputStreamError; // we've not been Open()ed
        // show progress...
        if(TotalSize)
            {
            int percent = TotalSize ? ((uint64_t)TransferredSize*(uint64_t)100)/(uint64_t)TotalSize : 0;
            printf("%8d bytes of %d - %3d%%\r",TransferredSize, TotalSize, percent);
            fflush(stdout);
            }
        else
            {
            printf("%8d bytes\r",TransferredSize);
            fflush(stdout);
            }
        // limit data to size of file...
        if(TotalSize)
            {
            size_t maxSize = TotalSize-TransferredSize;
            if(size>maxSize)
                size = maxSize;
            if(!maxSize)
                return 0; // end
            }
        // write data...
        if(size!=fwrite(data,sizeof(uint8_t),size,File))
            return YModemRx::ErrorOutputStreamError; // write failed
        TransferredSize += size;
        return size;
        }
private:
    FILE* File;
    size_t TotalSize;
    size_t TransferredSize;
    };


FILE* LogFile = 0;  
void CaptureLog(SerialPort* port)
    {
    printf("Capturing log to %s...\n",LogFileName);
    fflush(stdout);
    uint8_t logBuffer[1024+MAX_LOG_END_STRING_LENGTH];
    size_t bufferOffset = 0;
    for(;;)
        {
        uint8_t* start = logBuffer+bufferOffset;
        uint8_t* end = logBuffer+sizeof(logBuffer);
        size_t length = end-start;
        int result = port->In(start,length,LogTimeout);
        if(!result)
            {
            fclose(LogFile);
            printf("Log capture timeout.\n");
            return;
            }
        if(result<0)
            {
            fclose(LogFile);
            Error(result,"Error during log capture");
            }

        // save data to log...
        length = result;
        end = start+length;
        if(fwrite(start,1,length,LogFile)!=length)
            {
            fclose(LogFile);
            Error(ErrorLogFileError,"File error during log capture");
            }
        fflush(LogFile);

        if(LogEcho)
            {
#ifndef WIN32
            fwrite(start,1,length,stdout);
#else
            // Hack for windows because it expands LF character to CR+LF
            for(size_t i=0; i<length; ++i)
                if(start[i]!=13) // ignore CR characters
                    fwrite(start+i,1,1,stdout);
#endif
            fflush(stdout);
            }

        // check for terminating string...
        if(!LogEndStringLength)
            continue;
        uint8_t* endString = (uint8_t*)LogEndString;
        uint8_t firstEndChar = endString[0];
        size_t endStringLength = LogEndStringLength;
        uint8_t* scanEnd = end-endStringLength;
        uint8_t* scan = logBuffer;
        while(scan<=scanEnd)
            {
match_next: if(*scan++!=firstEndChar)
                continue;

            uint8_t* ptr = scan;
            size_t endStringMatch = 0;
            while(++endStringMatch<endStringLength)
                if(*ptr++!=endString[endStringMatch])
                    goto match_next;

            fclose(LogFile);
            printf("Log capture termination string found.\n");
            return;
            }
        bufferOffset = end-scan;
        memcpy(logBuffer,scan,bufferOffset);
        }
    }


void Send(SerialPort* port)
    {
    if(!FileName)
        UsageError("File argument missing");

    if(!DstFileName)
        DstFileName = FileName;

    InFile source;
    int error = source.Open(FileName);
    if(error)
        Error(error,"Can't open file '%s'",FileName);

    printf("Sending %s...\n",FileName);
    YModemTx ymodem(*port);
    if(XModemFlag)
        error = ymodem.SendX(source,Timeout,KModeFlag);
    else
        error = ymodem.SendY(DstFileName,source.Size(),source,Timeout);
    if(error)
        Error(error,"Error during file transfer");

    printf("\nSent OK\n");
    source.Close();
    }


void Receive(SerialPort* port)
    {
    OutFile destination;
    YModemRx ymodem(*port);
    int error;
    if(XModemFlag)
        {
        if(!FileName)
            UsageError("File argument missing");
        error = destination.Open(FileName,0);
        if(error)
            Error(error,"Can't create file '%s'",FileName);
        error = ymodem.ReceiveX(destination,Timeout,CrcFlag);
        }
    else
        {
        if(FileName)
            {
            error = destination.Open(FileName,0);
            if(error)
                Error(error,"Can't create file '%s'",FileName);
            }
        error = ymodem.ReceiveY(destination,Timeout,GModeFlag);
        }
    if(error)
        Error(error,"Error during file transfer");

    printf("\nReceived OK\n");
    destination.Close();
    }


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

    SerialPort* port = SerialPort::New();
    if(!port)
        Error(ErrorNoMemory,"Can't create port");

    int error = port->Open(PortNum);
    if(error)
        Error(error,"Can't open port");

    error = port->Initialise(PortBaud);
    if(error)
        Error(error,"Can't initialise port");

    if(ReceiveFlag)
        Receive(port);
    else
        {
        if(LogFileName)
            {
            LogFile = fopen(LogFileName,"w+b");
            if(!LogFile)
                Error(ErrorLogFileError,"Can't create LogFile file '%s'",LogFileName);
            }
        if(SendFlag || FileName)
            Send(port);
        if(LogFileName)
            CaptureLog(port);
        }

    port->Close();
    delete port;

    return 0;
    }

 // End of group