1 files changed, 5 insertions, 2 deletions
diff --git a/PumpKINDlg.cpp b/PumpKINDlg.cpp
index 2a01918..bb15211 100644
--- a/PumpKINDlg.cpp
+++ b/PumpKINDlg.cpp
@@ -685,297 +685,300 @@ CXferSocket::CXferSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKAD
        m_timeOut=m__timeOut=m_Daddy->m_TFTPTimeOut.GetTotalSeconds();
        if(sin){
                m_Peer.sin_addr.s_addr=sin->sin_addr.s_addr;
                m_Peer.sin_port=sin->sin_port;
        }else
                m_Peer.sin_addr.s_addr=INADDR_NONE;
        m_FileName=fileName;
        m_Type=type;
 }
 BOOL CRRQSocket::Create(LPCTSTR localFile,LPCTSTR hostName)
 {
        if(!CAsyncSocket::Create(0,SOCK_DGRAM))
                return FALSE;
        ASSERT(m_Daddy);
        ASSERT(m_Peer.sin_addr.s_addr!=INADDR_NONE || hostName);
        m_Daddy->m_Xfers[m_hSocket]=this;
 CString lFile = localFile?localFile:m_FileName;
        TurnSlashes(lFile,TRUE);
        UpdateList();
                if(!localFile){// Check only for incoming requests
                if(CheckBadRelativeness(m_FileName)){
                        Deny(tftp::errAccessViolation,IDS_TFTP_ERROR_ACCESS);
                        return TRUE;
                }
                int atar=m_Daddy->m_aclRules.FindTarget(acl_rule::opRRQ,m_Peer.sin_addr.s_addr);
                if(atar<0)
                        atar = m_Daddy->m_RRQMode;
                switch(atar){
                case CPumpKINDlg::rrqGiveAll:
                        break;
                case CPumpKINDlg::rrqAlwaysConfirm:
                        if(ConfirmRequest())
                                break;
                default:
                        TRACE1("Unexpected access target: %d\n",atar);
                case CPumpKINDlg::rrqDenyAll:
                        Deny(tftp::errAccessViolation,IDS_TFTP_ERROR_ACCESS);
                        return TRUE;
                }
        }
 CString fn = localFile?ApplyRootGently(lFile):ApplyRoot(lFile);
 CFileException e;
        if(!m_File.Open(fn,CFile::modeRead|CFile::shareDenyWrite,&e)){
                if(localFile){
                CString tmp;
                        tmp.Format(IDS_LOG_FAILEDLOCALFILE,fn);
                        m_Daddy->LogLine(tmp);
                        return FALSE;
                }
                Deny(&e);
                return TRUE;
        }
                m_xferSize=m_File.GetLength();// *** HANDLE EXCEPTION
        if(hostName){
                m_HostName=hostName;
        
        CString tmp;
                tmp.Format(IDS_LOG_SENDING,m_FileName,m_HostName);
                m_Daddy->LogLine(tmp);
                CString inAddr = hostName;
        int at = inAddr.Find('@');
                if(at>=0)
                        inAddr=inAddr.Mid(at+1);
                if((m_Peer.sin_addr.s_addr=inet_addr((LPCTSTR)inAddr))==INADDR_NONE){
                        ASSERT(!m_wndResolver);
                        m_wndResolver = new CResolver(this);
                        ASSERT(m_wndResolver);
                        return m_wndResolver->Resolve();
                }
                else
                        OnHostKnown();
        }else{
        tftp::tftpOptions o;
        CString v;
                if(m_Options.Lookup(tftpoBSize,v)){
                        m__blkSize=atoi(v);
                        if(m__blkSize){
                                m_blkSize=m__blkSize;
                                v.Format("%u",m_blkSize);
                                o[tftpoBSize]=v;
                        }
                }
                if(m_Options.Lookup(tftpoTSize,v)){
                        v.Format("%lu",m_xferSize);
                        o[tftpoTSize]=v;
                }
                if(m_Options.Lookup(tftpoTOut,v)){
                        m__timeOut=atoi(v);
                        if(m__timeOut){
                                m_timeOut=m__timeOut;
                                v.Format("%u",m_timeOut);
                                o[tftpoTOut]=v;
                        }
                }
+                // XXX: see if we can enforce our preference regarding block size here.
+                if(m_xferSize >= (m_blkSize<<16)) {
+                        Deny(tftp::errUndefined,IDS_TFTP_ERROR_TOOBIG);
+                        return TRUE;
+                }
                state = stateXfer;
                m_ACK=0;
                if(o.GetCount()){
                tftp *p = tftp::Allocate(tftp::tftpOACK::tftpSize(&o));
                        ASSERT(p);
                        p->SetOpcode(tftp::opOACK);
                        p->data.m_OACK.Set(&o);
                        PostTFTP(p,TRUE);
                }else
                        DoXfer();
        }
        return TRUE;
 }
 CRRQSocket::CRRQSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN *sin)
        : CXferSocket(daddy,fileName,type,sin)
 {
        m_ACK=0;
        m_LastSlack=0;
 }
 UINT tftp::tftpERROR::tftpSize(LPCTSTR msg)
 {
        return tftpHdrSize-tftpSlackSize+sizeof(tftp::tftpERROR::tftpErrorCode)+strlen(msg)+1;
 }
 tftp* tftp::Allocate(UINT tftpSize)
 {
        ASSERT(tftpSize);
 tftp* rv = (tftp*) new BYTE[tftpSlackSize+tftpSize];
        ASSERT(rv);
        rv->length=tftpSize;
        return rv;
 }
 void tftp::errSet(UINT code,LPCTSTR msg)
 {
        ASSERT(this);
        ASSERT(length>=data.m_ERROR.tftpSize(msg));
        strcpy((char*)data.m_ERROR.data,msg);
        data.m_ERROR.SetCode(code);
 }
 void CXferSocket::PostTFTP(tftp* p,BOOL retryable)
 {
        ASSERT(p);
        m_Queue.AddTail(p);
        DoSelect();
        if(!m_bRetry){
                if(retryable)
                        SetTry(p);
                else
                        SetTry();
        }
        ResetTimeout();
 }
 void CXferSocket::Deny(UINT errCode,UINT errID)
 {
        PostError(errCode,errID);
        state=stateDeny;
 }
 void CRRQSocket::DoXfer()
 {
 tftp *p = tftp::Allocate(tftp::tftpDATA::tftpSize(m_blkSize));
        ASSERT(p);
        p->SetOpcode(tftp::opDATA);
        TRY{
                m_File.Seek(m_ACK*m_blkSize,CFile::begin);
        int bytes = m_File.Read(p->data.m_DATA.data,m_blkSize);
                p->data.m_DATA.SetBlock(m_ACK+1);
                p->length=p->length-m_blkSize+bytes;
                m_LastSlack = m_blkSize-bytes;
                PostTFTP(p);
                if(bytes<m_blkSize){
                        state=stateClosing; m_ACKtoClose = m_ACK+1;
                }
        }CATCH(CFileException,e){
                Deny(e);
        }END_CATCH
 }
 UINT tftp::tftpDATA::tftpSize(UINT blkSize)
 {
        return tftpHdrSize-tftpSlackSize+sizeof(tftp::tftpDATA)
                -sizeof(BYTE)+blkSize;
 }
 void CXferSocket::Deny(CFileException* e)
 {
        PostError(e);
        state=stateDeny;
 }
 void CXferSocket::PostError(UINT errCode,UINT errID)
 {
 CString msg;
        msg.LoadString(errID);
        ASSERT(m_Daddy);
-        /*// ***
 CString tmp;
        tmp.Format(IDS_LOG_SENTTFTPERROR,errCode,(LPCTSTR)msg);
        m_Daddy->LogLine(tmp);
- */
 tftp* err = tftp::Allocate(tftp::tftpERROR::tftpSize(msg));
 err->SetOpcode(tftp::opERROR);
        err->errSet(errCode,msg);
        PostTFTP(err);
 }
 void CXferSocket::PostError(CFileException* e)
 {
 UINT eCode;
 UINT eMsgID;
        switch(e->m_cause){
        case CFileException::fileNotFound:
                eCode=tftp::errNotFound;
                eMsgID=IDS_TFTP_ERROR_NOTFOUND;
                break;
        case CFileException::accessDenied:
                eCode=tftp::errAccessViolation;
                eMsgID=IDS_TFTP_ERROR_ACCESS;
                break;
        case CFileException::directoryFull:
                eCode=tftp::errDiskFull;
                eMsgID=IDS_TFTP_ERROR_DIRFULL;
                break;
        case CFileException::sharingViolation:
                eCode=tftp::errAccessViolation;
                eMsgID=IDS_TFTP_ERROR_SHARING;
                break;
        case CFileException::diskFull:
                eCode=tftp::errDiskFull;
                eMsgID=IDS_TFTP_ERROR_DISKFULL;
                break;
        default:
                eCode=tftp::errUndefined;
                eMsgID=IDS_TFTP_ERROR_UNDEFINED;
                break;
        }
        PostError(eCode,eMsgID);
 }
 ULONG CRRQSocket::GetACK(void)
 {
        return (m_ACK*m_blkSize)-m_LastSlack;
 }
 BOOL CRRQSocket::OnTFTP(tftp* p)
 {
 BOOL rv = TRUE;
        switch(p->Opcode()){
        case tftp::opOACK:
                {
                        m_ACK=0;
                        ASSERT(state!=stateFinish);
                tftp::tftpOptions o;
                        if(p->GetOptions(&o)){
                        CString v;
                                if(o.Lookup(tftpoBSize,v)){
                                        m_blkSize=atoi(v);
                                                if(!m_blkSize){// *** More sanity checks
                                                Deny(tftp::errOption,IDS_TFTP_ERROR_BSIZE);
                                                rv = TRUE;
                                                break;
                                        }
                                }
                                if(o.Lookup(tftpoTOut,v)){
                                        m_timeOut=atoi(v);
                                                if(!m_timeOut){// *** More sanity checks
                                                Deny(tftp::errOption,IDS_TFTP_ERROR_TOUT);
                                                rv = TRUE;
                                                break;
                                        }
                                }
                                if(o.Lookup(tftpoXResume,v)){
                                        m_ACK=atoi(v);
                                }
                        }
                        UpdateList();
                        DoXfer();
                }
                break;
        case tftp::opACK:
                m_ACK=p->data.m_ACK.Block();
                if(state==stateClosing && m_ACK==m_ACKtoClose) {
                        state = stateFinish;
                        ASSERT(m_Daddy);
                CString tmp;
                        tmp.Format(IDS_LOG_XFERRRQFINISHED,(LPCTSTR)m_FileName);
                        m_Daddy->LogLine(tmp);
                        rv = FALSE;
                        DoSelect(TRUE);
                }else if(state!=stateFinish){
                        UpdateList();
                        DoXfer();
                }
                break;
        case tftp::opERROR:
                {