1 files changed, 169 insertions, 9 deletions
diff --git a/PumpKINDlg.h b/PumpKINDlg.h
index 42ae62d..b247c56 100644
--- a/PumpKINDlg.h
+++ b/PumpKINDlg.h
@@ -20,308 +20,468 @@ struct	tftp	{
                opWRQ = 2,
                opDATA = 3,
                opACK = 4,
                opERROR = 5,
                opOACK = 6,
                errUndefined = 0,
                errNotFound = 1,
                errAccessViolation = 2,
                errDiskFull = 3,
                errIllegalOp = 4,
                errUnknownTID = 5,
                errFileExists = 6,
                errNoUser = 7,
                errOption = 8
        };
                structtftpUNKNOWN {
                BYTE data[1];
        };
                structtftpRQ {
                BYTE data[1];
 public:
        void Set(LPCTSTR file,LPCTSTR type,tftpOptions* ops=NULL);
        static UINT tftpSize(LPCTSTR file,LPCTSTR type,tftpOptions* ops=NULL);
        };
                structtftpRRQ {
                BYTE data[1];
 public:
        void Set(LPCTSTR file,LPCTSTR type,tftpOptions* ops=NULL);
        static UINT tftpSize(LPCTSTR file,LPCTSTR type,tftpOptions* ops=NULL);
        };
                structtftpWRQ {
                BYTE data[1];
 public:
        void Set(LPCTSTR file,LPCTSTR type,tftpOptions* ops=NULL);
        static UINT tftpSize(LPCTSTR file,LPCTSTR type,tftpOptions* ops=NULL);
        };
                structtftpDATA {
                WORD block;
                BYTE data[1];
        public:
        WORD Block();
        void SetBlock(WORD b);
        static UINT tftpSize(UINT blkSize=512);
        };
        struct tftpACK {
                WORD block;
        public:
        static UINT tftpSize();
        void SetBlock(WORD b);
        WORD Block();
        };
                structtftpERROR {
                typedef WORD tftpErrorCode;
                tftpErrorCode code;
                BYTE data[1];
        public:
        void SetCode(WORD c);
        WORD Code();
                static UINT tftpSize(LPCTSTR msg);
        };
        struct tftpOACK {
                BYTE data[1];
        public:
        void Set(tftpOptions* ops);
                static UINT tftpSize(tftpOptions* ops);
        };
                uniontftpPacket {
                tftpUNKNOWN m_UNKNOWN;
                tftpRQ m_RQ;
                tftpRRQ m_RRQ;
                tftpWRQ m_WRQ;
                tftpDATA m_DATA;
                tftpACK m_ACK;
                tftpERROR m_ERROR;
                tftpOACK m_OACK;
                }data;
                void    *udpBase(void){ return &opcode; }
 public:
        static tftp* Copy(tftp *src);
        CString errMessage();
        void SetOpcode(WORD op);
        void errSet(UINT code,LPCTSTR msg);
        static tftp* Allocate(UINT tftpSize=0);
        BOOL Send(CAsyncSocket *socket,SOCKADDR_IN* saddr);
        CString rqType();
        CString rqFileName();
        UINT GetOptions(tftpOptions* ops);
        tftp();
        UINT Opcode();
        BOOL Receive(CAsyncSocket* socket,UINT maxLength,SOCKADDR_IN *sin=NULL);
 };
        #define         tftpHdrSize(sizeof(tftp)-sizeof(tftp::tftpPacket))
        #definetftpSlackSize sizeof(tftp::tftpLength)
+struct acl_rule {
+ enum {
+         opRRQ=tftp::opRRQ, opWRQ=tftp::opWRQ
+ };
+ int op;
+ DWORD addr, mask;
+ enum {
+        rrqGrant=0, rrqPrompt, rrqDeny,
+        rrqRules,
+        rrqNone=-1
+ };
+ enum {
+         wrqGrant=0, wrqPromptIfExists, wrqPrompt, wrqDeny,
+         wrqRules,
+         wrqNone=-1
+ };
+ int target;
+ acl_rule()
+         : op(-1), addr(0), mask(0), target(-1) { }
+ acl_rule(int o,DWORD a,DWORD m,int t)
+         : op(o), addr(a), mask(m), target(t) { }
+ acl_rule(const acl_rule& s)
+         : op(s.op), addr(s.addr), mask(s.mask), target(s.target) { }
+ BOOL IsValid() {
+         if(op==opRRQ) {
+                 if(target<rrqNone || target>=rrqRules)
+                         return FALSE;
+         }else if(op==opWRQ) {
+                 if(target<wrqNone || target>=wrqRules)
+                         return FALSE;
+         }else
+                 return FALSE;
+         return TRUE;
+ }
+ BOOL IsMatch(int o,DWORD a) {
+         if(o!=op) return FALSE;
+         if( (a&mask) != (addr&mask)) return FALSE;
+         return TRUE;
+ }
+ CString str_addr() {
+         return inet_ntoa(*(struct in_addr*)&addr);
+ }
+ CString str_mask() {
+         return inet_ntoa(*(struct in_addr*)&mask);
+ }
+ CString str_target() {
+         if(op==opRRQ) {
+                 switch(target) {
+                 case rrqNone: return "fallback";
+                 case rrqGrant: return "grant";
+                 case rrqPrompt: return "prompt";
+                 case rrqDeny: return "deny";
+                 default: return "?";
+                 }
+         }else if(op==opWRQ) {
+                 switch(target) {
+                 case wrqNone: return "fallback";
+                 case wrqGrant: return "grant";
+                 case wrqPromptIfExists: return "prompt if exists";
+                 case wrqPrompt: return "prompt";
+                 case wrqDeny: return "deny";
+                 default: return "?";
+                 }
+         }else
+                 return "?";
+ }
+ void SaveProfile(CWinApp* app,int i) {
+         CString n; n.Format("%d",i);
+         app->WriteProfileInt("ACL","op_"+n,op);
+         app->WriteProfileString("ACL","addr_"+n,str_addr());
+         app->WriteProfileString("ACL","mask_"+n,str_mask());
+         app->WriteProfileInt("ACL","target_"+n,target);
+ }
+ void LoadProfile(CWinApp* app,int i) {
+         CString n; n.Format("%d",i);
+         op=app->GetProfileInt("ACL","op_"+n,-1);
+         addr=inet_addr(app->GetProfileString("ACL","addr_"+n));
+         mask=inet_addr(app->GetProfileString("ACL","mask_"+n));
+         target=app->GetProfileInt("ACL","target_"+n,-1);
+ }
+};
+class acl_rules_t : public CArray<acl_rule,acl_rule&> {
+public:
+        acl_rules_t& operator=(const acl_rules_t& s) {
+                // Copy(s); XXX: unsuprisingly, there's a bug in MFC Copy, *pDst++=*pSrc (no ++ for Src)
+                RemoveAll();
+                int ns = s.GetSize();
+                SetSize(ns);
+                for(int i=0;i<ns;++i)
+                        m_pData[i]=s.m_pData[i];
+                return *this;
+        }
+        int AppendRule(acl_rule& r) {
+                return Add(r);
+        }
+        void DeleteRule(int r) {
+                RemoveAt(r);
+        }
+        int FindRule(int op,DWORD ip) {
+                for(int i=0;i<GetSize();++i)
+                        if(m_pData[i].IsMatch(op,ip))
+                                return i;
+                return -1;
+        }
+        int FindTarget(int op,DWORD ip) {
+                int r=FindRule(op,ip);
+                if(r<0) return -1;
+                return m_pData[r].target;
+        }
+        void SaveProfile(CWinApp* app) {
+                int s=GetSize();
+                for(int i=0;i<s;++i)
+                        m_pData[i].SaveProfile(app,i);
+                app->WriteProfileInt("ACL","rules",s);
+        }
+        void LoadProfile(CWinApp* app) {
+                RemoveAll();
+                int s=app->GetProfileInt("ACL","rules",0);
+                for(int i=0;i<s;++i) {
+                        acl_rule r;
+                        r.LoadProfile(app,i);
+                        if(r.IsValid())
+                                Add(r);
+                }
+        }
+};
 class CPumpKINDlg;
        class CListenSocket : public CAsyncSocket{
 public:
-        virtual void OnReceive(int nErrorCode);
        CPumpKINDlg* m_Daddy;
+        BOOL m_bListen;
+        CListenSocket()
+                : m_bListen(FALSE), m_Daddy(0) { }
+        BOOL SetListen(BOOL b);
+        virtual void OnReceive(int nErrorCode);
 };
        typedef         CList<tftp*,tftp*>CTFTPList;
 class CResolver;
        class CXferSocket : public CAsyncSocket{
 public:
        UINT m__timeOut;
        UINT m__blkSize;
        tftp::tftpOptions m_Options;
        LONG m_xferSize;
        UINT m_timeOut;
        UINT m_blkSize;
        BOOL m_bRetry;
        void SetTry(tftp *p=NULL);
        tftp* m_Retry;
        void OnRetry();
        BOOL CheckBadRelativeness(LPCTSTR file);
        CString ApplyRootGently(LPCTSTR fn);
        CString m_HostName;
        virtual void OnResolved();
        virtual void OnFailedToResolve();
        CResolver *m_wndResolver;
        BYTE m_ResolveBuff[MAXGETHOSTSTRUCT];
        virtual void Abort();
        void ResetTimeout();
                enum{
                stateNone, stateDeny, stateInit, stateOACK, stateXfer, stateFinish, stateClosing
        };
        int state;
        void Deny(UINT errCode,UINT errID);
        void Deny(CFileException* e);
        CString ApplyRoot(LPCTSTR fileName);
        void TurnSlashes(CString& fn,BOOL bBack=TRUE);
        virtual void Destroy(BOOL success=TRUE);
        void PostError(CFileException* e);
        void PostError(UINT errCode,UINT errID);
        void PostTFTP(tftp* p,BOOL retryable=FALSE);
        CXferSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN* sin);
        CFile m_File;
        virtual ULONG GetACK();
        CString m_Type;
        CString m_FileName;
        CXferSocket();
        void UpdateList();
        void SetPeer(SOCKADDR_IN *sin);
        virtual BOOL OnTFTP(tftp* p) = 0;
        virtual void OnReceive(int nErrorCode);
        void DoSelect();
        SOCKADDR_IN m_Peer;
        virtual void OnSend(int nErrorCode);
        CPumpKINDlg* m_Daddy;
        CTFTPList m_Queue;
        DECLARE_DYNAMIC(CXferSocket)
 };
 class CWRQSocket : public CXferSocket {
 public:
        BOOL m_bResume;
        void OnHostKnown();
        virtual void OnResolved();
        UINT m_LastSlack;
        ULONG GetACK();
        void DoXfer();
        UINT m_ACK;
        BOOL SaveAs(CString& fn);
        BOOL RenameFile(CString& fn);
        BOOL m_Rename;
        BOOL ConfirmRequest();
        BOOL Create(LPCTSTR localFile=NULL,LPCTSTR hostName=NULL);
        CWRQSocket(CPumpKINDlg* daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN *sin);
        BOOL OnTFTP(tftp* p);
        DECLARE_DYNAMIC(CWRQSocket)
 };
 class CRRQSocket : public CXferSocket {
 public:
        void OnHostKnown();
        virtual void OnResolved();
        BOOL ConfirmRequest();
        WORD m_LastSlack;
        UINT m_ACK;
        BOOL OnTFTP(tftp* p);
        ULONG GetACK(void);
        void DoXfer();
        CRRQSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN *sin);
        BOOL Create(LPCTSTR localFile=NULL,LPCTSTR hostName=NULL);
        DECLARE_DYNAMIC(CRRQSocket)
 };
        typedef         CMap<SOCKET,SOCKET,CXferSocket*,CXferSocket*>CTIDMap;
 typedef CMap<CTime*,CTime*,CTime*,CTime*> CTimeMap;
 /////////////////////////////////////////////////////////////////////////////
 // CPumpKINDlg dialog
 class CTrayer;
 class CRetrier;
 class CPumpKINDlg : public CDialog
 {
 // Construction
 public:
+        CString m_lastlogerr;
+        void LogLine(LPCTSTR str);
+        CString m_LogFile;
+        BOOL m_bListen;
+        acl_rules_t m_aclRules;
        CString m_bnwRequest;
        CString m_bnwSuccess;
        CString m_bnwAbort;
        CBellsNWhistles m_bnw;
        CTrayer *m_Trayer;
        CTimeSpan m_RetryTimeOut;
        virtual ~CPumpKINDlg();
        CRetrier* m_Retrier;
        virtual BOOL PreTranslateMessage(MSG* pMsg);
        BOOL m_bShown;
        BOOL m_bExiting;
        void SaveSettings();
        void LoadSettings();
        void SetupButtons();
        BITMAP m_bitmapBack;
        CBitmap m_bmpBack;
        UINT m_PromptTimeOut;
        UINT m_SpeakPort;
        void LogLine(UINT msgID);
        CTimeMap m_LogTimes;
-        void LogLine(LPCTSTR str);
+        void LogLineToFile(LPCTSTR str);
+        void LogLineToScreen(LPCTSTR str);
        int m_LogLength;
                enum{
                subitemFile=0, subitemType, subitemPeer, subitemBytes, subitemTSize
        };
        int m_iWRQ;
        int m_iRRQ;
        CImageList m_Images;
        CTIDMap m_Xfers;
        CTimeSpan m_TFTPTimeOut;
                enum{
-                rrqGiveAll=0,
+                rrqGiveAll=acl_rule::rrqGrant,
-                rrqAlwaysConfirm,
+                rrqAlwaysConfirm=acl_rule::rrqPrompt,
-                rrqDenyAll
+                rrqDenyAll=acl_rule::rrqDeny,
+                rrqFallback=acl_rule::rrqNone,
+                rrqGrant=rrqGiveAll, rrqDeny=rrqDenyAll, rrqPrompt=rrqAlwaysConfirm
        };
                enum{
-                wrqTakeAll=0,
+                wrqTakeAll=acl_rule::wrqGrant,
-                wrqConfirmIfExists,
+                wrqConfirmIfExists=acl_rule::wrqPromptIfExists,
-                wrqAlwaysConfirm,
+                wrqAlwaysConfirm=acl_rule::wrqPrompt,
-                wrqDenyAll
+                wrqDenyAll=acl_rule::wrqDeny,
+                wrqFallback=acl_rule::wrqNone,
+                wrqGrant=wrqTakeAll,wrqDeny=wrqDenyAll, wrqPrompt=wrqAlwaysConfirm
        };
        UINT m_RRQMode;
        UINT m_WRQMode;
        BOOL m_bTFTPSubdirs;
        CString m_TFTPRoot;
        UINT m_ListenPort;
        UINT m_BlockSize;
        CListenSocket m_Listener;
                CPumpKINDlg(CWnd* pParent = NULL);// standard constructor
 // Dialog Data
        //{{AFX_DATA(CPumpKINDlg)
        enum { IDD = IDD_PUMPKIN_DIALOG };
+                CButtonm_ListenCtl;
                CButtonm_AbortCtl;
                CButtonm_OptionsCtl;
                CListBoxm_Log;
                CListCtrlm_List;
        //}}AFX_DATA
        // ClassWizard generated virtual function overrides
        //{{AFX_VIRTUAL(CPumpKINDlg)
        protected:
                virtual void DoDataExchange(CDataExchange* pDX);// DDX/DDV support
        //}}AFX_VIRTUAL
 // Implementation
 protected:
        CToolTipCtrl m_tooltip;
        HICON m_hIcon;
        // Generated message map functions
        //{{AFX_MSG(CPumpKINDlg)
        virtual BOOL OnInitDialog();
        afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
        afx_msg void OnDestroy();
        afx_msg void OnPaint();
        afx_msg HCURSOR OnQueryDragIcon();
        afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
        afx_msg void OnOptions();
        afx_msg void OnTimer(UINT nIDEvent);
        afx_msg void OnExit();
        afx_msg void OnPut();
        afx_msg void OnGet();
        afx_msg void OnDeleteallitemsConnections(NMHDR* pNMHDR, LRESULT* pResult);
        afx_msg void OnDeleteitemConnections(NMHDR* pNMHDR, LRESULT* pResult);
        afx_msg void OnInsertitemConnections(NMHDR* pNMHDR, LRESULT* pResult);
        afx_msg void OnItemchangedConnections(NMHDR* pNMHDR, LRESULT* pResult);
        afx_msg void OnAbort();
        afx_msg void OnClose();
        afx_msg void OnTrayShowpumpkinwindow();
+        afx_msg void OnTrayListen();
        afx_msg void OnTrayExit();
        afx_msg void OnTrayAboutpumpkin();
        afx_msg void OnTrayFetchfile();
        afx_msg void OnTrayHelp();
        afx_msg void OnTrayOptions();
        afx_msg void OnTraySendfile();
        afx_msg void OnWindowPosChanging(WINDOWPOS FAR* lpwndpos);
        afx_msg void OnSelchangeLog();
        afx_msg void OnTrayOpenfilesfolder();
        afx_msg void OnDropFiles(HDROP hDropInfo);
        virtual void OnCancel();
        afx_msg void OnHelp();
+        afx_msg void OnListening();
        //}}AFX_MSG
        DECLARE_MESSAGE_MAP()
 };