network settings: bind to specific ip address

Signed-off-by: Michael Krelin <hacker@klever.net>

1 files changed, 1 insertions, 0 deletions

diff --git a/PumpKINDlg.h b/PumpKINDlg.h
index 23c2657..9077292 100644..100755
--- a/PumpKINDlg.h
+++ b/PumpKINDlg.h
@@ -1,501 +1,502 @@
 // PumpKINDlg.h : header file

 //

 

         //#define       REVERSEBYTES(w)MAKEWORD(HIBYTE(w),LOBYTE(w));

         #defineREVERSEBYTES(w) (htons((WORD)w))

         #define         tftpoBSize"blksize"

         #define         tftpoTSize"tsize"

         #define         tftpoTOut"timeout"

 

         #define         tftpoXResume"x-resume"

 

         struct  tftp{

         typedef CMapStringToString tftpOptions;

         typedef WORD tftpLength;

         typedef WORD tftpOpcode;

                 tftpLengthlength;

         tftpOpcode opcode;

                 enum{

                 opRRQ = 1,

                 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:

         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(BOOL do_select=FALSE);

         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:

         UINT m_ACKtoClose;

         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:

         void AdjustButton(CWnd& w,CRect& wrc);

         void RecalcLayout(int,int);

         CSize m_MinSize;

         UINT m_bottomGapLog;

         UINT m_bottomGapListen;

         UINT m_rightGapList;

         UINT m_rightGapButtons;

         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 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=acl_rule::rrqGrant,

                 rrqAlwaysConfirm=acl_rule::rrqPrompt,

                 rrqDenyAll=acl_rule::rrqDeny,

                 rrqFallback=acl_rule::rrqNone,

                 rrqGrant=rrqGiveAll, rrqDeny=rrqDenyAll, rrqPrompt=rrqAlwaysConfirm

         };

                 enum{

                 wrqTakeAll=acl_rule::wrqGrant,

                 wrqConfirmIfExists=acl_rule::wrqPromptIfExists,

                 wrqAlwaysConfirm=acl_rule::wrqPrompt,

                 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;

+        CString m_ListenAddress;

         UINT m_BlockSize;

         CListenSocket m_Listener;

                 CPumpKINDlg(CWnd* pParent = NULL);// standard constructor

 

 // Dialog Data

         //{{AFX_DATA(CPumpKINDlg)

         enum { IDD = IDD_PUMPKIN_DIALOG };

                 CButtonm_HelpCtl;

                 CButtonm_PutCtl;

                 CButtonm_GetCtl;

                 CButtonm_ExitCtl;

                 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 void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);

         afx_msg void OnSize(UINT nType, int cx, int cy);

         //}}AFX_MSG

         DECLARE_MESSAGE_MAP()

 };