invalid opcode during xfer message shows the opcode itself now.

git-svn-id: http://svn.klever.net/kin/pumpkin/trunk@48 fe716a7a-6dde-0310-88d9-d003556173a8

1 files changed, 14 insertions, 6 deletions

diff --git a/PumpKINDlg.cpp b/PumpKINDlg.cpp
index fc24596..b6b8a36 100644
--- a/PumpKINDlg.cpp
+++ b/PumpKINDlg.cpp
@@ -816,339 +816,347 @@ tftp *p = tftp::Allocate(tftp::tftpDATA::tftpSize(m_blkSize));
                 CString tmp;

                         tmp.Format(IDS_LOG_XFERRRQFINISHED,(LPCTSTR)m_FileName);

                         m_Daddy->LogLine(tmp);

                 }

         }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!=stateFinish){

                         UpdateList();

                         DoXfer();

                 }

                 break;

         case tftp::opERROR:

                 {

                         ASSERT(m_Daddy);

                 CString tmp;

                         tmp.Format(IDS_LOG_GOTTFTPERROR,p->data.m_ERROR.Code(),(LPCTSTR)p->errMessage());

                         m_Daddy->LogLine(tmp);

                 }

                 Destroy(FALSE);

                 rv = FALSE;

                 break;

         default:

-                ASSERT(m_Daddy);

-                m_Daddy->LogLine(IDS_LOG_XFEROPCODE);

-                // *** Self destruct maybe??

+                {

+                        ASSERT(m_Daddy);

+                        CString tmp;

+                        tmp.Format(IDS_LOG_XFEROPCODE,p->Opcode());

+                        m_Daddy->LogLine(tmp);

+                        // *** Self destruct maybe??

+                }

                 break;

         }

         return rv;

 }

 

 BOOL CWRQSocket::OnTFTP(tftp* p)

 {

         switch(p->Opcode()){

         case tftp::opOACK:

                 ASSERT(state!=stateFinish);

         {

                 if(m_bResume)

                         m_ACK=m_File.GetLength()/m_blkSize;

                 else

                         m_ACK=0;

         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);

                                         return TRUE;

                                 }

                         }

                         if(o.Lookup(tftpoTOut,v)){

                                 m_timeOut=atoi(v);

                                         if(!m_timeOut){// *** More sanity checks

                                         Deny(tftp::errOption,IDS_TFTP_ERROR_TOUT);

                                         return TRUE;

                                 }

                         }

                         if(o.Lookup(tftpoTSize,v)){

                                 m_xferSize=atoi(v);

                         }

                 }

                 UpdateList();

                 DoXfer();

         }

                 break;

         case tftp::opDATA:

                 {

                         UINTblock = p->data.m_DATA.Block();

                         TRY{

                                 m_File.Seek((block-1)*m_blkSize,CFile::begin);

                         int bytes = p->length-sizeof(p->data.m_DATA.block)-(tftpHdrSize-tftpSlackSize);

                                 if(bytes){

                                         m_File.Write(p->data.m_DATA.data,bytes);

                                         // *** Move to the other place where we can do it not that often

                                         m_File.SetLength(m_File.GetPosition());

                                 }

                                 if(bytes<m_blkSize){

                                         state=stateFinish;

                                         ASSERT(m_Daddy);

                                 CString tmp;

                                         tmp.Format(IDS_LOG_XFERWRQFINISHED,(LPCTSTR)m_FileName);

                                         m_Daddy->LogLine(tmp);

                                 }

                                 m_ACK=block;

                                 m_LastSlack=m_blkSize-bytes;

                                 UpdateList();

                                 DoXfer();

                         }CATCH(CFileException,e){

                                 Deny(e);

                         }END_CATCH

                 }

                 break;

         case tftp::opERROR:

                 {

                         ASSERT(m_Daddy);

                 CString tmp;

                         tmp.Format(IDS_LOG_GOTTFTPERROR,p->data.m_ERROR.Code(),(LPCTSTR)p->errMessage());

                         m_Daddy->LogLine(tmp);

                 }

                 Destroy(FALSE);

                 return FALSE;

         default:

-                ASSERT(m_Daddy);

-                m_Daddy->LogLine(IDS_LOG_XFEROPCODE);

-                // *** Self destruct maybe??

+                {

+                        ASSERT(m_Daddy);

+                        CString tmp;

+                        tmp.Format(IDS_LOG_XFEROPCODE,p->Opcode());

+                        m_Daddy->LogLine(tmp);

+                        // *** Self destruct maybe??

+                }

                 break;

         }

         return TRUE;

 }

 

 void tftp::SetOpcode(WORD op)

 {

         opcode = REVERSEBYTES(op);

 }

 void tftp::tftpDATA::SetBlock(WORD b)

 {

         block=REVERSEBYTES(b);

 }

 WORD tftp::tftpDATA::Block()

 {

         return REVERSEBYTES(block);

 }

 WORD tftp::tftpACK::Block()

 {

         return REVERSEBYTES(block);

 }

 void tftp::tftpACK::SetBlock(WORD b)

 {

         block = REVERSEBYTES(b);

 }

 WORD tftp::tftpERROR::Code()

 {

         return REVERSEBYTES(code);

 }

 void tftp::tftpERROR::SetCode(WORD c)

 {

         code = REVERSEBYTES(c);

 }

 

 

 CString tftp::errMessage()

 {

 CString rv;

         if(memchr(data.m_ERROR.data,0,length-(tftpHdrSize-tftpSlackSize)-sizeof(data.m_ERROR.code)))

                 rv = (LPCTSTR)data.m_ERROR.data;

         return rv;

 }

 

 void CXferSocket::Destroy(BOOL success)

 {

         if(m_wndResolver){

                 delete m_wndResolver;

                 m_wndResolver=NULL;

         }

         SetTry();

         m_Daddy->m_bnw.StartSound(

                 success

                         ? m_Daddy->m_bnwSuccess

                         : m_Daddy->m_bnwAbort

         );

         if(m_File.m_hFile!=CFile::hFileNull){

                 TRY{

                         m_File.Close();

                 }CATCH(CFileException,e){

                         TRACE0("Error closing file\n");

                 }END_CATCH

         }

         ASSERT(m_Daddy);

         m_Daddy->KillTimer(m_hSocket);

         m_Daddy->m_Xfers.RemoveKey(m_hSocket);

 LV_FINDINFO lvf;

         memset(&lvf,0,sizeof(lvf));

         lvf.flags=LVFI_PARAM;

         lvf.lParam=(LPARAM)this;

 int i = m_Daddy->m_List.FindItem(&lvf);

         if(i>=0)

                 m_Daddy->m_List.DeleteItem(i);

         delete this;

 }

 

 void CPumpKINDlg::LogLine(LPCTSTR str)

 {

         ASSERT(m_LogLength);

         while(m_Log.GetCount()>m_LogLength && m_Log.GetCount()!=LB_ERR){

         CTime *t = (CTime*)m_Log.GetItemData(0);

                 if(((DWORD)t)!=LB_ERR){

                         ASSERT(t);

                         m_LogTimes.RemoveKey(t);

                         delete t;

                 }

                 m_Log.DeleteString(0);

         }

 int i = m_Log.AddString(str);

         ASSERT(i!=LB_ERR);

 CTime *t = new CTime(CTime::GetCurrentTime());

         m_Log.SetItemData(i,(DWORD)(m_LogTimes[t]=t));

         m_Log.SetCurSel(i);

 }

 

 void CPumpKINDlg::LogLine(UINT msgID)

 {

 CString tmp;

         tmp.Format(msgID);

         LogLine(tmp);

 }

 

 void CXferSocket::TurnSlashes(CString& fn,BOOL bBack)

 {

         ints = fn.Find(bBack?'/':'\\');

         while(s>=0){

                 fn.SetAt(s,bBack?'\\':'/');

                 s = fn.Find(bBack?'/':'\\');

         }

 }

 

 CString CXferSocket::ApplyRoot(LPCTSTR fileName)

 {

         ASSERT(m_Daddy);

 CString fn  = fileName;

 CString rv = m_Daddy->m_TFTPRoot;

         if(rv.IsEmpty())

                 rv = ".";

         if(rv[rv.GetLength()-1]!='\\')

                 rv+="\\";

         while((!fn.IsEmpty()) && fn[0]=='\\')

                 fn=fn.Mid(1);

         rv+=fn;

         return rv;

 }

 

 void CPumpKINDlg::OnOptions() 

 {

 CPropertySheet cps(IDS_TITLE_OPTIONS,this);