From 5305ddd8332ebd905ebef3b8365fc0d736858a7a Mon Sep 17 00:00:00 2001 From: Michael Krelin Date: Mon, 05 Jul 2004 01:53:09 +0000 Subject: initial commit into svn repository git-svn-id: http://svn.klever.net/kin/dipstick/trunk@1 fe716a7a-6dde-0310-88d9-d003556173a8 --- (limited to 'DipstickDlg.cpp') diff --git a/DipstickDlg.cpp b/DipstickDlg.cpp new file mode 100644 index 0000000..ace2aff --- a/dev/null +++ b/DipstickDlg.cpp @@ -0,0 +1,1586 @@ +// DipstickDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "Dipstick.h" +#include "DipstickDlg.h" +#include "DragPad.h" +#include "OptionsDlg.h" +#include "HostNameDlg.h" +#include "HostProperties.h" +#include "AutoBestDlg.h" +#include "ddeml.h" + +#include "URLSource.h" +#include "SelectURLsDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CAboutDlg dialog used for App About + +class CAboutDlg : public CDialog +{ +public: + CAboutDlg(); + +// Dialog Data + //{{AFX_DATA(CAboutDlg) + enum { IDD = IDD_ABOUTBOX }; + //}}AFX_DATA + + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CAboutDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + virtual BOOL OnInitDialog(); + //{{AFX_MSG(CAboutDlg) + afx_msg void OnKlevernet(); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) +{ + //{{AFX_DATA_INIT(CAboutDlg) + //}}AFX_DATA_INIT +} + +void CAboutDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CAboutDlg) + //}}AFX_DATA_MAP +} + +BEGIN_MESSAGE_MAP(CAboutDlg, CDialog) + //{{AFX_MSG_MAP(CAboutDlg) + ON_BN_CLICKED(IDC_KLEVERNET, OnKlevernet) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CDipstickDlg dialog + +CDipstickDlg::CDipstickDlg(CWnd* pParent /*=NULL*/) + : CDialog(CDipstickDlg::IDD, pParent), + m_DragPad(NULL), m_PingsPerHost(10), m_PingSize(32), m_TimeOut(5000), m_Interval(500), + m_SortCriteria(sortAvg), m_bShown(FALSE), m_MaxThreads(10), m_bExiting(FALSE), + m_bMSWorkAround(TRUE), m_MinSize(-1,-1), m_bAutoBest(TRUE), m_bSmartAdjust(TRUE), + m_bAdjustInnermost(TRUE), m_ActiveThreads(0), m_bIgnorelative(TRUE) +{ +CWinApp *app = AfxGetApp(); + ASSERT(app); +WORD hi,lo; + hi=app->GetProfileInt("Options","IntervalHi",HIWORD(m_Interval)); + lo=app->GetProfileInt("Options","IntervalLo",LOWORD(m_Interval)); + m_Interval=MAKELONG(lo,hi); + m_MaxThreads=app->GetProfileInt("Options","MaxThreads",m_MaxThreads); + m_PingSize=app->GetProfileInt("Options","PingSize",m_PingSize); + m_PingsPerHost=app->GetProfileInt("Options","PingsPerHost",m_PingsPerHost); + m_SortCriteria=app->GetProfileInt("Options","SortBy",m_SortCriteria); + hi=app->GetProfileInt("Options","TimeOutHi",HIWORD(m_TimeOut)); + lo=app->GetProfileInt("Options","TimeOutLo",LOWORD(m_TimeOut)); + m_TimeOut=MAKELONG(lo,hi); + m_bMSWorkAround = app->GetProfileInt("Options","InnermostURL",m_bMSWorkAround); + m_bAutoBest = app->GetProfileInt("Options","AutoBest",m_bAutoBest); + m_bSmartAdjust = app->GetProfileInt("Options","SmartAdjust",m_bSmartAdjust); + m_bAdjustInnermost = app->GetProfileInt("Options","AdjustInnermost",m_bAdjustInnermost); + m_bIgnorelative = app->GetProfileInt("Options","IgnoreRelative",m_bIgnorelative); + m_impexPath = app->GetProfileString("Options","ImportExportPath",m_impexPath); + //{{AFX_DATA_INIT(CDipstickDlg) + //}}AFX_DATA_INIT + // Note that LoadIcon does not require a subsequent DestroyIcon in Win32 + m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); + m_bmpBack.LoadBitmap(IDB_DIABACK); + m_bmpBack.GetBitmap(&m_bitmapBack); +CString tmp; + VERIFY(tmp.LoadString(IDS_REGEX_HTMLURL)); + VERIFY(m_reHTMLURL.Compile(tmp,CRegEx::regExtended|CRegEx::regIgnoreCase)); +} + +CDipstickDlg::~CDipstickDlg() +{ +} + +void CDipstickDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CDipstickDlg) + DDX_Control(pDX, IDC_ADVANCED, m_AdvancedCtl); + DDX_Control(pDX, ID_HELP, m_HelpCtl); + DDX_Control(pDX, IDC_EXIT, m_ExitCtl); + DDX_Control(pDX, IDC_OPTIONS, m_OptionsCtl); + DDX_Control(pDX, IDC_MANUALPING, m_ManualPingCtl); + DDX_Control(pDX, IDC_REMOVE, m_RemoveCtl); + DDX_Control(pDX, IDC_REPINGALL, m_RepingAllCtl); + DDX_Control(pDX, IDC_REPING, m_RepingCtl); + DDX_Control(pDX, IDC_CLEAR, m_ClearListCtl); + DDX_Control(pDX, IDC_HOSTLIST, m_HostList); + //}}AFX_DATA_MAP +} + +BEGIN_MESSAGE_MAP(CDipstickDlg, CDialog) + //{{AFX_MSG_MAP(CDipstickDlg) + ON_WM_SYSCOMMAND() + ON_WM_PAINT() + ON_WM_QUERYDRAGICON() + ON_WM_DESTROY() + ON_BN_CLICKED(IDC_OPTIONS, OnOptions) + ON_MESSAGE(WM_DNP_URLPING, OnUrlPing) + ON_MESSAGE(WM_DNP_ACTIVITYCOUNT, OnActivityCount) + ON_MESSAGE(WM_DNP_UPDATEHOSTDATA, OnUpdateHostData) + ON_MESSAGE(WM_DNP_HTML, OnHTMLTransfer) + ON_NOTIFY(LVN_COLUMNCLICK, IDC_HOSTLIST, OnColumnclickHostlist) + ON_WM_WINDOWPOSCHANGING() + ON_COMMAND(ID_DRAGPAD_OPTIONS, OnDragpadOptions) + ON_COMMAND(ID_DRAGPAD_SHOWMAINWINDOW, OnDragpadShowmainwindow) + ON_COMMAND(ID_DRAGPAD_HELP, OnDragpadHelp) + ON_COMMAND(ID_DRAGPAD_ABOUT, OnDragpadAbout) + ON_COMMAND(ID_DRAGPAD_EXIT, OnDragpadExit) + ON_BN_CLICKED(IDC_MANUALPING, OnManualping) + ON_COMMAND(ID_DRAGPAD_MANUALPING, OnDragpadManualping) + ON_COMMAND(ID_DRAGPAD_REPINGALL, OnDragpadRepingAll) + ON_COMMAND(ID_DRAGPAD_REMOVEALL, OnDragpadRemoveAll) + ON_BN_CLICKED(IDC_REPING, OnReping) + ON_BN_CLICKED(IDC_REPINGALL, OnRepingall) + ON_BN_CLICKED(IDC_CLEAR, OnClear) + ON_NOTIFY(LVN_INSERTITEM, IDC_HOSTLIST, OnInsertitemHostlist) + ON_NOTIFY(LVN_DELETEITEM, IDC_HOSTLIST, OnDeleteitemHostlist) + ON_NOTIFY(LVN_DELETEALLITEMS, IDC_HOSTLIST, OnDeleteallitemsHostlist) + ON_BN_CLICKED(IDC_EXIT, OnExit) + ON_NOTIFY(LVN_ITEMCHANGED, IDC_HOSTLIST, OnItemchangedHostlist) + ON_BN_CLICKED(IDC_REMOVE, OnRemove) + ON_NOTIFY(NM_RCLICK, IDC_HOSTLIST, OnRclickHostlist) + ON_COMMAND(ID_HOSTLIST_REPING, OnHostListReping) + ON_COMMAND(ID_HOSTLIST_REMOVE, OnHostListRemove) + ON_COMMAND(ID_HOSTLIST_REPINGALL, OnHostListRepingAll) + ON_COMMAND(ID_HOSTLIST_REMOVEALL, OnHostListRemoveAll) + ON_COMMAND(ID_HOSTLIST_OPENURL, OnHostListOpenURL) + ON_COMMAND(ID_HOSTLIST_PROPERTIES, OnHostListProperties) + ON_NOTIFY(NM_DBLCLK, IDC_HOSTLIST, OnDblclkHostlist) + ON_WM_CLOSE() + ON_WM_GETMINMAXINFO() + ON_WM_SIZE() + ON_BN_CLICKED(ID_HELP, OnHelp) + ON_NOTIFY(LVN_BEGINDRAG, IDC_HOSTLIST, OnBegindragHostlist) + ON_COMMAND(ID_HOSTLIST_PASTEURL, OnPasteurl) + ON_COMMAND(ID_HOSTLIST_COPYURL, OnHostlistCopyurl) + ON_WM_HELPINFO() + ON_WM_DROPFILES() + ON_BN_CLICKED(IDC_ADVANCED, OnAdvanced) + ON_COMMAND(ID_ADVANCED_EXPORTLIST, OnAdvancedExportlist) + ON_COMMAND(ID_ADVANCED_IMPORTLIST, OnAdvancedImportlist) + ON_COMMAND(ID_DRAGPAD_PASTEURL, OnPasteurl) + ON_COMMAND(ID_DRAGPAD_ADVANCED_EXPORTLIST, OnDragpadAdvancedExportlist) + ON_COMMAND(ID_DRAGPAD_ADVANCED_IMPORTLIST, OnDragpadAdvancedImportlist) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CDipstickDlg message handlers + +BOOL CDipstickDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + // Add "About..." menu item to system menu. + + // IDM_ABOUTBOX must be in the system command range. + ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); + ASSERT(IDM_ABOUTBOX < 0xF000); + + CMenu* pSysMenu = GetSystemMenu(FALSE); + CString strAboutMenu; + strAboutMenu.LoadString(IDS_ABOUTBOX); + if (!strAboutMenu.IsEmpty()) + { + pSysMenu->AppendMenu(MF_SEPARATOR); + pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); + } + + // Set the icon for this dialog. The framework does this automatically + // when the application's main window is not a dialog + SetIcon(m_hIcon, TRUE); // Set big icon + SetIcon(m_hIcon, FALSE); // Set small icon + +CRect wrci, wrco; + GetWindowRect(&wrco); + GetClientRect(&wrci); +CRect brc1, brc2, lrc; + m_HostList.GetWindowRect(&lrc); + ScreenToClient(&lrc); + m_ManualPingCtl.GetWindowRect(&brc1); + ScreenToClient(brc1); + m_RepingCtl.GetWindowRect(&brc2); + ScreenToClient(&brc2); + m_OverX = lrc.left; + m_OverY = lrc.top; + m_GapY = brc2.top - brc1.bottom; + m_MinSize.cx = m_OverX+m_OverX+m_OverX+brc1.Width()+m_OverX; + m_MinSize.cy = m_OverY+(brc1.Height()+m_GapY)*6+(brc1.Height()+m_GapY)*3+m_OverY; + m_MinSize.cx+=wrco.Width()-wrci.Width(); + m_MinSize.cy+=wrco.Height()-wrci.Height(); + +CWinApp *app = AfxGetApp(); + ASSERT(app); +CRect wrc; + wrc.top=app->GetProfileInt("Windows","DlgTop",-1); + wrc.bottom=app->GetProfileInt("Windows","DlgBottom",-1); + wrc.left=app->GetProfileInt("Windows","DlgLeft",-1); + wrc.right=app->GetProfileInt("Windows","DlgRight",-1); + if((wrc.top!=-1|| wrc.bottom!=-1) && wrc.left!=-1&& wrc.right!=-1) + MoveWindow(&wrc); + + RecalcLayout(-1,-1); + + m_DragPad = new CDragPad(); + m_DragPad->m_Daddy=this; + m_DragPad->Create(CDragPad::IDD); + m_Images.Create(16,16,TRUE,4,1); + m_iPending=m_Images.Add(app->LoadIcon(IDI_PENDING)); + m_iPinging=m_Images.Add(app->LoadIcon(IDI_PINGING)); + m_iCompleted=m_Images.Add(app->LoadIcon(IDI_COMPLETED)); + m_iUnreachable=m_Images.Add(app->LoadIcon(IDI_UNREACHABLE)); + ASSERT(!(m_iPending<0 || m_iPinging<0 || m_iCompleted<0 || m_iUnreachable<0)); + m_HostList.SetImageList(&m_Images,LVSIL_NORMAL); + m_HostList.SetImageList(&m_Images,LVSIL_SMALL); + m_HostList.SetImageList(&m_Images,LVSIL_STATE); + m_HostList.SetTextColor(RGB(255,255,0)); // Yellow + m_HostList.SetTextBkColor(RGB(12,167,0)); // Green + m_HostList.SetBkColor(RGB(12,167,0)); // Green +CRect listrc; + m_HostList.GetClientRect(&listrc); + m_HostList.InsertColumn(0,"Host Name",LVCFMT_LEFT,app->GetProfileInt("Columns","HostName",listrc.Width()-(listrc.Width()*2/16)*4-(listrc.Width()*3/16)),subitemHost); + m_HostList.InsertColumn(1,"Host IP",LVCFMT_LEFT,app->GetProfileInt("Columns","HostIP",listrc.Width()*3/16),subitemIP); + m_HostList.InsertColumn(2,"Min RTT",LVCFMT_RIGHT,app->GetProfileInt("Columns","MinRTT",listrc.Width()*2/16),subitemMin); + m_HostList.InsertColumn(3,"Avg RTT",LVCFMT_RIGHT,app->GetProfileInt("Columns","AvgRTT",listrc.Width()*2/16),subitemAvg); + m_HostList.InsertColumn(4,"Max RTT",LVCFMT_RIGHT,app->GetProfileInt("Columns","MaxRTT",listrc.Width()*2/16),subitemMax); + m_HostList.InsertColumn(5,"Pktloss", LVCFMT_RIGHT,app->GetProfileInt("Columns","PktLoss",listrc.Width()*2/16),subitemPacketloss); + + DragAcceptFiles(TRUE); + + return TRUE; // return TRUE unless you set the focus to a control +} + +void CDipstickDlg::OnSysCommand(UINT nID, LPARAM lParam) +{ + if ((nID & 0xFFF0) == IDM_ABOUTBOX) + { + CAboutDlg dlgAbout; + dlgAbout.DoModal(); + } + else + { + CDialog::OnSysCommand(nID, lParam); + } +} + +// If you add a minimize button to your dialog, you will need the code below +// to draw the icon. For MFC applications using the document/view model, +// this is automatically done for you by the framework. + +void CDipstickDlg::OnPaint() +{ + if (IsIconic()) + { + CPaintDC dc(this); // device context for painting + + SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0); + + // Center icon in client rectangle + int cxIcon = GetSystemMetrics(SM_CXICON); + int cyIcon = GetSystemMetrics(SM_CYICON); + CRect rect; + GetClientRect(&rect); + int x = (rect.Width() - cxIcon + 1) / 2; + int y = (rect.Height() - cyIcon + 1) / 2; + + // Draw the icon + dc.DrawIcon(x, y, m_hIcon); + } + else + { + CPaintDC pDC(this); + CDC bmpDC; + bmpDC.CreateCompatibleDC(&pDC); + bmpDC.SelectObject(&m_bmpBack); + CRect rc; + GetClientRect(&rc); + for(int x=-m_bitmapBack.bmWidth*2/4;xDestroyWindow(); + delete m_DragPad; + m_DragPad=NULL; + // *** Eventually move the following code to separate function +POSITION p = m_Hosts.GetHeadPosition(); + while(p){ + POSITION pp = p; + CPingyHost *host = m_Hosts.GetNext(p); + ASSERT(host); + m_Hosts.RemoveAt(pp); + host->Suicide(); + } + ASSERT(m_Hosts.IsEmpty()); +} + +void CDipstickDlg::OnOptions() +{ +COptionsDlg o(this); + o.m_Pings = m_PingsPerHost; + o.m_PingSize = m_PingSize; + o.m_TimeOut = max(1,m_TimeOut/1000); + o.m_Interval = max(1,m_Interval/1000); + o.m_MaxThreads = m_MaxThreads; + o.m_bMSWorkAround = m_bMSWorkAround; + o.m_bAutoBest = m_bAutoBest; + o.m_bAdjust = m_bSmartAdjust; + o.m_bAdjustInn = m_bAdjustInnermost; + o.m_bIgnorelative = m_bIgnorelative; + if(o.DoModal()==IDOK){ + m_PingsPerHost = o.m_Pings; + m_PingSize = o.m_PingSize; + m_TimeOut = o.m_TimeOut*1000; + m_Interval = o.m_Interval*1000; + m_MaxThreads = o.m_MaxThreads; + m_bMSWorkAround = o.m_bMSWorkAround; + m_bAutoBest = o.m_bAutoBest; + m_bSmartAdjust = o.m_bAdjust; + m_bAdjustInnermost = o.m_bAdjustInn; + m_bIgnorelative = o.m_bIgnorelative; + } +} + +BOOL CDipstickDlg::AddPingyHost(CPingyHost *host) +{ + m_Hosts.AddTail(host); +int i = m_HostList.InsertItem(0,host->m_HostName); + m_HostList.SetItemData(i,(DWORD)host); + UpdateDragpadTitle(); + return UpdatePingyHost(host,i); // *** Do someting if failed. +} + +BOOL CDipstickDlg::UpdatePingyHost(CPingyHost *host,int index) +{ + UpdateDragpadTitle(); +int i = index; + if(i<0){ + int is = m_HostList.GetItemCount(); + for(i=0;im_HostName.IsEmpty()?"...":host->m_HostName); + m_HostList.SetItemText(i,subitemIP,host->m_IP?inet_ntoa(*(in_addr*)&host->m_IP):"..."); + if(host->m_Pinged && host->m_Packetloss>=0){ + CString tmp; + if(host->m_Packetloss==100){ + m_HostList.SetItemText(i,subitemMin,"-"); + m_HostList.SetItemText(i,subitemAvg,"-"); + m_HostList.SetItemText(i,subitemMax,"-"); + }else{ + tmp.Format("%lu",host->m_MinRTT); + m_HostList.SetItemText(i,subitemMin,tmp); + tmp.Format("%lu",host->m_AvgRTT); + m_HostList.SetItemText(i,subitemAvg,tmp); + tmp.Format("%lu",host->m_MaxRTT); + m_HostList.SetItemText(i,subitemMax,tmp); + } + tmp.Format("%d%%",host->m_Packetloss); + m_HostList.SetItemText(i,subitemPacketloss,tmp); + }else{ + m_HostList.SetItemText(i,subitemMin,"..."); + m_HostList.SetItemText(i,subitemAvg,"..."); + m_HostList.SetItemText(i,subitemMax,"..."); + m_HostList.SetItemText(i,subitemPacketloss,"..."); + } + if(host->m_Pinging) + m_HostList.SetItem(i,subitemHost,LVIF_IMAGE,NULL,m_iPinging,0,0,0); + else{ + if(host->m_bToPing) + m_HostList.SetItem(i,subitemHost,LVIF_IMAGE,NULL,m_iPending,0,0,0); + else{ + if(host->m_Pinged){ + if(host->m_Packetloss==100) + m_HostList.SetItem(i,subitemHost,LVIF_IMAGE,NULL,m_iUnreachable,0,0,0); + else + m_HostList.SetItem(i,subitemHost,LVIF_IMAGE,NULL,m_iCompleted,0,0,0); + }else + m_HostList.SetItem(i,subitemHost,LVIF_IMAGE,NULL,m_iPending,0,0,0); + } + } + m_HostList.SortItems(CompareItems,(DWORD)this); + UpdateControlButtons(); + return TRUE; +} + +BOOL CDipstickDlg::RemovePingyHost(CPingyHost *host,int index) +{ + if(host->m_Pinging) + return FALSE; +int i = index; + if(i<0){ + int is = m_HostList.GetItemCount(); + for(i=0;iSuicide(); + UpdateControlButtons(); + UpdateDragpadTitle(); + return TRUE; +} + +LRESULT CDipstickDlg::OnUrlPing(WPARAM wP, LPARAM lP) +{ + ASSERT(lP); +CString *u = (CString*)lP; +CString hn; +CPingyHost *host; + if(m_bMSWorkAround) + hn = CCrackURL::InnermostURL(*u); + else + hn = *u; + hn = CCrackURL::GetHostName(hn); +DWORD ip = inet_addr(hn); + if(ip==INADDR_NONE) + host = new CPingyHost(this,(char*)(LPCTSTR)hn); + else + host = new CPingyHost(this,ip); + host->m_URL=*u; + delete u; + AddPingyHost(host); + CheckForPendingRequests(); + return 0; +} + +LRESULT CDipstickDlg::OnActivityCount(WPARAM wP,LPARAM) +{ + if(!wP) + return 0; +int crement = (int)wP; + m_ActiveThreads+=crement; + if(m_ActiveThreads<0){ + TRACE0("C'est n'est pas possible!\n"); + m_ActiveThreads=0; + } + TRACE1("AC: %d\n",m_ActiveThreads); + if(m_ActiveThreads){ + m_DragPad->m_DragNDropTarget.Play(0,(UINT)-1,(UINT)-1); + m_ClearListCtl.EnableWindow(FALSE); + }else{ + m_DragPad->m_DragNDropTarget.Stop(); + m_DragPad->m_DragNDropTarget.Seek(0); + if(m_HostList.GetItemCount()) + m_ClearListCtl.EnableWindow(TRUE); + } + if(crement>0) + return 0; + UpdateDragpadTitle(); +int items = m_HostList.GetItemCount(); + if((!CheckForPendingRequests()) && m_bAutoBest && items && !m_ActiveThreads){ + // Come up with the best URL.. + m_SortCriteria=sortAvg; + m_HostList.SortItems(CompareItems,(DWORD)this); + CPtrArray hs; + for(int tmp=0;tmpm_Pinging); + ASSERT(host->m_Pinged); + if(host->m_Packetloss==100 || host->m_URL.IsEmpty()) + continue; + hs.Add(host); + } + if(hs.GetSize()){ + int item = 0; + if(!::PlaySound((LPCTSTR)IDW_BESTURL,AfxGetApp()->m_hInstance,SND_ASYNC|SND_NODEFAULT|SND_NOSTOP|SND_NOWAIT|SND_RESOURCE)) + MessageBeep(0xFFFFFFFF); + for(;;){ + CPingyHost *host = (CPingyHost*)hs[item]; + CAutoBestDlg abd; + abd.m_bPrev = (item>0); + abd.m_bNext = (itemm_Packetloss); + abd.m_RTT.Format("%lu",host->m_AvgRTT); + abd.m_URL=host->m_URL; + int rv = abd.DoModal(); + if(rv==IDOK){ + ShellExecute(::GetDesktopWindow(),"open",host->m_URL,NULL,NULL,SW_SHOWMAXIMIZED); + CString title, text; + VERIFY(title.LoadString(IDS_ABEST_TITLE)); + VERIFY(text.LoadString(IDS_ABEST_CLEANUP)); + if(MessageBox(text,title,MB_YESNO|MB_ICONQUESTION|MB_APPLMODAL)==IDYES) + OnClear(); + break; + }else if(rv==IDCANCEL){ + break; + }else if(rv==IDC_PREV){ + item--; + ASSERT(item>=0); + }else if(rv==IDC_NEXT){ + item++; + ASSERT(itemm_SortCriteria; + switch(criteria){ + case sortHost: + return h1->m_HostName.CompareNoCase(h2->m_HostName); + case sortIP: + return htonl(h1->m_IP)-htonl(h2->m_IP); + default: + if(h1->m_Pinged){ + if(!h2->m_Pinged) + return -1; + if(h1->m_Packetloss==100){ + if(h2->m_Packetloss!=100) + return 1; + return 0; + }else{ + if(h2->m_Packetloss==100) + return -1; + } + }else{ + if(h2->m_Pinged) + return 1; + break; + } + switch(criteria){ + case sortMin: + return h1->m_MinRTT-h2->m_MinRTT; + case sortAvg: + return h1->m_AvgRTT-h2->m_AvgRTT; + case sortMax: + return h1->m_MaxRTT-h2->m_MaxRTT; + case sortLoss: + return h1->m_Packetloss-h2->m_Packetloss; + } + } + return 0; +} + +void CDipstickDlg::OnColumnclickHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ + NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + switch(pNMListView->iSubItem){ + case subitemHost: m_SortCriteria=sortHost; break; + case subitemIP: m_SortCriteria=sortIP; break; + case subitemMin: m_SortCriteria=sortMin; break; + case subitemAvg: m_SortCriteria=sortAvg; break; + case subitemMax: m_SortCriteria=sortMax; break; + case subitemPacketloss: m_SortCriteria=sortLoss; break; + } + m_HostList.SortItems(CompareItems,(DWORD)this); + *pResult = 0; +} + +BOOL CDipstickDlg::PreCreateWindow(CREATESTRUCT& cs) +{ + cs.style&=~WS_VISIBLE; + return CDialog::PreCreateWindow(cs); +} + +void CDipstickDlg::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) +{ + CDialog::OnWindowPosChanging(lpwndpos); + if(!m_bExiting){ + if(m_bShown){ + lpwndpos->flags&=~SWP_HIDEWINDOW; + lpwndpos->flags|=SWP_SHOWWINDOW; + }else{ + lpwndpos->flags&=~SWP_SHOWWINDOW; + lpwndpos->flags|=SWP_HIDEWINDOW; + } + } +} + +void CDipstickDlg::OnDragpadOptions() +{ + OnOptions(); +} +void CDipstickDlg::OnDragpadShowmainwindow() +{ + m_DragPad->ToggleMainWindowDisplay(); +} +void CDipstickDlg::OnDragpadHelp() +{ + OnHelp(); +} +void CDipstickDlg::OnDragpadAbout() +{ +CAboutDlg dlgAbout; + dlgAbout.DoModal(); +} +void CDipstickDlg::OnDragpadExit() +{ + // *** More threading-aware + OnOK(); +} + +int CDipstickDlg::CheckForPendingRequests() +{ +static BOOL bChecking = FALSE; + if(bChecking) + return -1; + bChecking = TRUE; + TRACE1("CFPR: AC: %d\n",m_ActiveThreads); +int newRequests = m_MaxThreads-m_ActiveThreads; +POSITION p = m_Hosts.GetHeadPosition(); +int rv = 0; + while(newRequests>0 && p){ + CPingyHost *host = m_Hosts.GetNext(p); + ASSERT(host); + if(host->m_Pinging) + continue; + if(!host->m_bToPing) + continue; + TRACE0("!"); + host->Ping(); + newRequests--; + rv++; + } + TRACE0("/CFPR\n"); + bChecking = FALSE; + return rv; +} + +void CAboutDlg::OnKlevernet() +{ +CString url; + url.LoadString(IDS_KLEVERNET_URL); + ShellExecute(::GetDesktopWindow(),"open",url,NULL,NULL,SW_SHOWMAXIMIZED); +} + +void CDipstickDlg::OnOK() +{ +CWinApp *app = AfxGetApp(); + ASSERT(app); + app->WriteProfileInt("Options","IntervalHi",HIWORD(m_Interval)); + app->WriteProfileInt("Options","IntervalLo",LOWORD(m_Interval)); + app->WriteProfileInt("Options","MaxThreads",m_MaxThreads); + app->WriteProfileInt("Options","PingSize",m_PingSize); + app->WriteProfileInt("Options","PingsPerHost",m_PingsPerHost); + app->WriteProfileInt("Options","SortBy",m_SortCriteria); + app->WriteProfileInt("Options","TimeOutHi",HIWORD(m_TimeOut)); + app->WriteProfileInt("Options","TimeOutLo",LOWORD(m_TimeOut)); + app->WriteProfileInt("Options","InnermostURL",m_bMSWorkAround); + app->WriteProfileInt("Options","AutoBest",m_bAutoBest); + app->WriteProfileInt("Options","SmartAdjust",m_bSmartAdjust); + app->WriteProfileInt("Options","AdjustInnermost",m_bAdjustInnermost); + app->WriteProfileInt("Options","IgnoreRelative",m_bIgnorelative); + app->WriteProfileString("Options","ImportExportPath",m_impexPath); +CRect rc; + GetWindowRect(&rc); + app->WriteProfileInt("Windows","DlgTop",rc.top); + app->WriteProfileInt("Windows","DlgBottom",rc.bottom); + app->WriteProfileInt("Windows","DlgLeft",rc.left); + app->WriteProfileInt("Windows","DlgRight",rc.right); + m_DragPad->GetWindowRect(&rc); + app->WriteProfileInt("Windows","DragPadTop",rc.top); + app->WriteProfileInt("Windows","DragPadLeft",rc.left); + // Columns + app->WriteProfileInt("Columns","HostName",m_HostList.GetColumnWidth(0)); + app->WriteProfileInt("Columns","HostIP",m_HostList.GetColumnWidth(1)); + app->WriteProfileInt("Columns","MinRTT",m_HostList.GetColumnWidth(2)); + app->WriteProfileInt("Columns","AvgRTT",m_HostList.GetColumnWidth(3)); + app->WriteProfileInt("Columns","MaxRTT",m_HostList.GetColumnWidth(4)); + app->WriteProfileInt("Columns","PktLoss",m_HostList.GetColumnWidth(5)); + m_bExiting=TRUE; + CDialog::OnOK(); +} + +void CDipstickDlg::OnCancel() +{ +} + +void CDipstickDlg::OnManualping() +{ +CHostNameDlg hnd(this); + if(hnd.DoModal()==IDOK && !hnd.m_Host.IsEmpty()){ + CString *host = new CString(hnd.m_Host); + ASSERT(host); + PostMessage(WM_DNP_URLPING,0,(LPARAM)host); + } +} + +void CDipstickDlg::OnDragpadManualping() +{ + OnManualping(); +} + +void CDipstickDlg::OnDragpadRepingAll() +{ + OnRepingall(); +} +void CDipstickDlg::OnDragpadRemoveAll() +{ + OnClear(); +} + +void CDipstickDlg::OnReping() +{ + if(!m_HostList.GetSelectedCount()) + return; +int items = m_HostList.GetItemCount(); + for(int tmp=0;tmpm_Pinged && !host->m_Pinging) + host->m_bToPing=TRUE; + } + UpdateDragpadTitle(); + CheckForPendingRequests(); +} + +void CDipstickDlg::OnRepingall() +{ +POSITION p = m_Hosts.GetHeadPosition(); + while(p){ + CPingyHost *host = m_Hosts.GetNext(p); + ASSERT(host); + if(host->m_Pinged && !host->m_Pinging) + host->m_bToPing=TRUE; + } + UpdateDragpadTitle(); + CheckForPendingRequests(); +} + +void CDipstickDlg::OnClear() +{ + if(m_ActiveThreads) + return; + m_HostList.DeleteAllItems(); + // *** Eventually move the following code to separate function +POSITION p = m_Hosts.GetHeadPosition(); + while(p){ + POSITION pp = p; + CPingyHost *host = (CPingyHost*)m_Hosts.GetNext(p); + ASSERT(host); + m_Hosts.RemoveAt(pp); + host->Suicide(); + } + ASSERT(m_Hosts.IsEmpty()); + UpdateDragpadTitle(); +} + +void CDipstickDlg::OnInsertitemHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ +NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + m_RepingCtl.EnableWindow(TRUE); + m_RepingAllCtl.EnableWindow(TRUE); + UpdateDragpadTitle(); + *pResult = 0; +} + +void CDipstickDlg::OnDeleteitemHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ +NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + if(!m_HostList.GetItemCount()){ + m_RepingCtl.EnableWindow(FALSE); + m_RepingAllCtl.EnableWindow(FALSE); + m_ClearListCtl.EnableWindow(FALSE); + } + UpdateDragpadTitle(); + *pResult = 0; +} + +void CDipstickDlg::OnDeleteallitemsHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ +NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + m_RepingCtl.EnableWindow(FALSE); + m_RepingAllCtl.EnableWindow(FALSE); + m_ClearListCtl.EnableWindow(FALSE); + UpdateDragpadTitle(); + *pResult = 0; +} + +void CDipstickDlg::OnExit() +{ + OnOK(); +} + +void CDipstickDlg::OnItemchangedHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ +NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + if(pNMListView->uChanged&LVIF_STATE && (pNMListView->uOldState&LVIS_SELECTED)!=(pNMListView->uNewState&LVIS_SELECTED)) + UpdateControlButtons(); + UpdateDragpadTitle(); + *pResult = 0; +} + +void CDipstickDlg::UpdateControlButtons() +{ +int items = m_HostList.GetItemCount(); + if(!items){ + m_ClearListCtl.EnableWindow(FALSE); + m_RemoveCtl.EnableWindow(FALSE); + m_RepingAllCtl.EnableWindow(FALSE); + m_RepingCtl.EnableWindow(FALSE); + return; + } +BOOL cl = m_ActiveThreads?FALSE:TRUE, rm = FALSE, ra = FALSE, rp = FALSE; + for(int tmp=0;tmpm_Pinging){ + ra=TRUE; + if(m_HostList.GetItemState(tmp,LVIS_SELECTED)&LVIS_SELECTED){ + rp = TRUE; + rm = TRUE; + break; + } + } + } + m_ClearListCtl.EnableWindow(cl); + m_RemoveCtl.EnableWindow(rm); + m_RepingAllCtl.EnableWindow(ra); + m_RepingCtl.EnableWindow(rp); +} + +void CDipstickDlg::OnRemove() +{ + if(!m_HostList.GetSelectedCount()) + return; +int items = m_HostList.GetItemCount(); + for(int tmp=0;tmpm_Pinging) + RemovePingyHost(host,tmp); + } +} + +void CDipstickDlg::OnRclickHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ + if(!m_HostList.GetSelectedCount()) + return; +int items = m_HostList.GetItemCount(); +int item = -1; + for(int tmp=0;tmp=0); +CPoint p; + VERIFY(m_HostList.GetItemPosition(item,&p)); +CPingyHost *host = (CPingyHost*)m_HostList.GetItemData(item); + ASSERT(host); + m_HostList.ClientToScreen(&p); +CMenu menus; + VERIFY(menus.LoadMenu(IDR_MENU)); +CMenu *popUp = menus.GetSubMenu(1); + ASSERT(popUp); + UpdateControlButtons(); + popUp->EnableMenuItem(ID_HOSTLIST_REPING,MF_BYCOMMAND|(m_RepingCtl.IsWindowEnabled()?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_REMOVE,MF_BYCOMMAND|(m_RemoveCtl.IsWindowEnabled()?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_REMOVEALL,MF_BYCOMMAND|(m_ClearListCtl.IsWindowEnabled()?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_REPINGALL,MF_BYCOMMAND|(m_RepingAllCtl.IsWindowEnabled()?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_OPENURL,MF_BYCOMMAND|((m_HostList.GetSelectedCount()==1 && !host->m_URL.IsEmpty())?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_COPYURL,MF_BYCOMMAND|((m_HostList.GetSelectedCount()==1 && !host->m_URL.IsEmpty())?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_PROPERTIES,MF_BYCOMMAND|((m_HostList.GetSelectedCount()==1)?MF_ENABLED:MF_GRAYED)); + popUp->EnableMenuItem(ID_HOSTLIST_PASTEURL,MF_BYCOMMAND|(IsPasteableClipboard()?MF_ENABLED:MF_GRAYED)); + popUp->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON|TPM_LEFTBUTTON,p.x,p.y,this); + *pResult = 0; +} + +void CDipstickDlg::OnHostListReping() +{ + OnReping(); +} +void CDipstickDlg::OnHostListRemove() +{ + OnRemove(); +} +void CDipstickDlg::OnHostListRepingAll() +{ + OnRepingall(); +} +void CDipstickDlg::OnHostListRemoveAll() +{ + OnClear(); +} +void CDipstickDlg::OnHostListOpenURL() +{ + if(m_HostList.GetSelectedCount()!=1) + return; +int items = m_HostList.GetItemCount(); + for(int tmp=0;tmpm_URL.IsEmpty()) + ShellExecute(::GetDesktopWindow(),NULL,host->m_URL,NULL,NULL,SW_SHOWMAXIMIZED); +} + +void CDipstickDlg::OnHostListProperties() +{ + if(m_HostList.GetSelectedCount()!=1) + return; +int items = m_HostList.GetItemCount(); + for(int tmp=0;tmp0 && m_MinSize.cy>0){ + lpMMI->ptMinTrackSize.x = m_MinSize.cx; + lpMMI->ptMinTrackSize.y = m_MinSize.cy; + } +} + +void CDipstickDlg::OnSize(UINT nType, int cx, int cy) +{ + CDialog::OnSize(nType, cx, cy); + if(nType==SIZE_RESTORED) + RecalcLayout(cx,cy); +} + +void CDipstickDlg::RecalcLayout(int,int) +{ +CRect wrc; + GetClientRect(&wrc); +CRect brc; + m_ManualPingCtl.GetWindowRect(&brc); + m_HostList.SetWindowPos(NULL,m_OverX,m_OverY,wrc.Width()-m_OverX*3-brc.Width(),wrc.Height()-m_OverY*2,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOZORDER); +int xb = wrc.Width()-m_OverX-brc.Width(); +int cyb = brc.Height()+m_GapY; + m_ManualPingCtl.SetWindowPos(NULL,xb,m_OverY,0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_RepingCtl.SetWindowPos(NULL,xb,m_OverY+cyb,0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_RepingAllCtl.SetWindowPos(NULL,xb,m_OverY+cyb*2,0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_RemoveCtl.SetWindowPos(NULL,xb,m_OverY+cyb*3,0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_ClearListCtl.SetWindowPos(NULL,xb,m_OverY+cyb*4,0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_AdvancedCtl.SetWindowPos(NULL,xb,m_OverY+cyb*5,0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_ExitCtl.SetWindowPos(NULL,xb,wrc.Height()-m_OverY-brc.Height(),0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_OptionsCtl.SetWindowPos(NULL,xb,wrc.Height()-m_OverY-cyb-brc.Height(),0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); + m_HelpCtl.SetWindowPos(NULL,xb,wrc.Height()-m_OverY-cyb*2-brc.Height(),0,0,SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS); +} + +void CDipstickDlg::OnHelp() +{ + WinHelp(0,HELP_FINDER); +} + +void CDipstickDlg::UpdateDragpadTitle() +{ +int ic = m_HostList.GetItemCount(); +CString title; + if(!ic){ + VERIFY(title.LoadString(IDS_DRAGPAD_TITLE)); + }else{ + int ip = 0; + POSITION p = m_Hosts.GetHeadPosition(); + while(p){ + CPingyHost *host = m_Hosts.GetNext(p); + ASSERT(host); + if(!(host->m_Pinging || host->m_bToPing)) + ip++; + } + title.Format(IDS_DRAGPAD_URLS,ip,ic); + } + if(m_DragPad) + m_DragPad->SetWindowText(title); +} + +void CDipstickDlg::OnBegindragHostlist(NMHDR* pNMHDR, LRESULT* pResult) +{ + NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + + if(pNMListView->iItem>=0){ + CPingyHost *host = (CPingyHost*) m_HostList.GetItemData(pNMListView->iItem); + ASSERT(host); + if(!host->m_URL.IsEmpty()){ + CURLSource us(host->m_URL); + us.DoDragDrop(DROPEFFECT_COPY|DROPEFFECT_LINK); + } + } + + *pResult = 0; +} + +void CDipstickDlg::OnPasteurl() +{ +COleDataObject odo; + if(!odo.AttachClipboard()) + return; + CollectURLs(&odo,FALSE); +} + +BOOL CDipstickDlg::IsPasteableClipboard() +{ +COleDataObject odo; + if(!odo.AttachClipboard()) + return FALSE; + if(CollectURLs(&odo,TRUE)) + return TRUE; + return FALSE; +} + +BOOL CDipstickDlg::CollectURLs(COleDataObject* pDO,BOOL bTestOnly) +{ +UINT cfURL = RegisterClipboardFormat("UniformResourceLocator"); +UINT cfHTML = RegisterClipboardFormat("HTML Format"); +UINT cfNIF = RegisterClipboardFormat("Netscape Image Format"); + if(pDO->IsDataAvailable(cfURL)){ + if(!bTestOnly){ + HGLOBAL hg = pDO->GetGlobalData(cfURL); + ASSERT(hg); + LPVOID lpv = GlobalLock(hg); + ASSERT(lpv); + PostMessage(WM_DNP_URLPING,0,(LPARAM)new CString((LPCTSTR)lpv)); + GlobalUnlock(hg); + GlobalFree(hg); + } + return TRUE; + } + if(pDO->IsDataAvailable(cfHTML)){ + HGLOBAL hg = pDO->GetGlobalData(cfHTML); + ASSERT(hg); + LPCTSTR lps = (LPCTSTR)GlobalLock(hg); + ASSERT(lps); + BOOL rv = FALSE; + do{ + static LPCTSTR v10 = "Version:1.0\r\n"; + if(memcmp(v10,lps,strlen(v10))) + break; + static LPCTSTR strStartSelection = "StartSelection:"; + static LPCTSTR strEndSelection = "EndSelection:"; + static LPCTSTR strSourceURL = "SourceURL:"; + LPTSTR subs = strstr(lps,strStartSelection); + if(!subs) + break; + LONG startSelection = atol(&subs[strlen(strStartSelection)]); + if(!startSelection) + break; + if(!(subs=strstr(lps,strEndSelection))) + break; + LONG endSelection = atol(&subs[strlen(strEndSelection)]); + if(!endSelection) + break; + if(!(subs=strstr(lps,strSourceURL))) + break; + subs = &subs[strlen(strSourceURL)]; + LPTSTR eol = strchr(subs,'\r'); + if(!eol) + break; + (*eol)=0; + CString sourceURL = subs; + if(!sourceURL.GetLength()) + break; + TRACE0("SourceURL = "+sourceURL+"\n"); + _xferHTML* xf = new _xferHTML; + VERIFY(xf->src.Crack(sourceURL)); + LPTSTR htmlBuff = xf->html.GetBuffer(endSelection-startSelection+2); + ASSERT(htmlBuff); + memmove(htmlBuff,&lps[startSelection],endSelection-startSelection+1); + htmlBuff[endSelection-startSelection+1]=0; + xf->html.ReleaseBuffer(); + if(bTestOnly){ + rv = m_reHTMLURL.Match(xf->html); + delete xf; + }else{ + PostMessage(WM_DNP_HTML,0,(LPARAM)xf); + } + }while(FALSE); + GlobalUnlock(hg); + GlobalFree(hg); + return rv; + } + if(pDO->IsDataAvailable(cfNIF)){ + if(!bTestOnly){ + HGLOBAL hg = pDO->GetGlobalData(cfNIF); + ASSERT(hg); + LPVOID lpv = GlobalLock(hg); + ASSERT(lpv); + struct _nif { + BYTE data[0x20]; + DWORD m_offDescr; + DWORD m_offURL; + DWORD m_offToImage; + } *nif = (_nif*)lpv; + PostMessage(WM_DNP_URLPING,0,(LPARAM)new CString((LPCTSTR)&nif->data[nif->m_offURL])); + GlobalUnlock(hg); + GlobalFree(hg); + } + return TRUE; + } + if(pDO->IsDataAvailable(CF_TEXT)){ + if(!bTestOnly){ + HGLOBAL hg = pDO->GetGlobalData(CF_TEXT); + ASSERT(hg); + LPVOID lpv = GlobalLock(hg); + ASSERT(lpv); + PostMessage(WM_DNP_URLPING,0,(LPARAM)new CString((LPCTSTR)lpv)); + GlobalUnlock(hg); + GlobalFree(hg); + } + return TRUE; + } + return FALSE; +} + +LRESULT CDipstickDlg::OnHTMLTransfer(WPARAM wP, LPARAM lP) +{ +_xferHTML* xf = (_xferHTML*)lP; +CSelectURLsDlg su; + su.m_bAdjust = m_bSmartAdjust; + su.m_bAdjustInnermost = m_bAdjustInnermost; + BeginWaitCursor(); + while(m_reHTMLURL.Match(xf->html)){ + CString url = m_reHTMLURL.GetMatch(1); + xf->html = m_reHTMLURL.GetMatch(CRegEx::matchPostMatch); + if(CCrackURL::GetHostName(url)==url){ + if(m_bIgnorelative) + continue; + CCrackURL cracked; + VERIFY(cracked.Crack(url)); + cracked.Adjust(xf->src); + url = cracked.Build(); + } + if(!su.m_URLs.Find(url)) + VERIFY(su.m_URLs.AddTail(url)); + } + EndWaitCursor(); + delete xf; + if(su.DoModal()==IDOK){ + POSITION p = su.m_URLs.GetHeadPosition(); + while(p){ + CString url = su.m_URLs.GetNext(p); + PostMessage(WM_DNP_URLPING,0,(LPARAM)new CString(url)); + } + } + return 0; +} + +UINT CPingyHost::PingProc(LPVOID pParam) +{ +CPingyHost* pThis = (CPingyHost*)pParam; + ASSERT(pThis->m_Daddy); + return pThis->DoPing(); +} + +UINT CPingyHost::DoPing() +{ +CSingleLock slock(&m_mutex); + if(!slock.Lock(2000)){ + m_Status.LoadString(IDS_PS_FAILEDTOLOCK); + return 1; + } + m_Pinging = TRUE; + m_bToPing = FALSE; + VERIFY(m_Daddy->m_eveStartup.SetEvent()); + m_Daddy->PostMessage(WM_DNP_UPDATEHOSTDATA,0,(LPARAM)this); +in_addr ip; +UINT packets, lost; + packets=lost=0; +CICMP* pICMP = NULL; +UINT dataSize = m_Daddy->m_PingSize; +int ploss = 100; + do{ + if(m_HostName.IsEmpty()){ + ip.s_addr = m_IP; + hostent *he = gethostbyaddr((char*)&ip,4,PF_INET); + if(!he) + m_HostName.Empty(); + else + m_HostName = he->h_name; + }else{ + hostent *he = gethostbyname(m_HostName); + if(!he){ + m_Status.LoadString(IDS_PS_FAILEDTORESOLVE); + m_IP = 0; + break; + } + memmove(&ip.s_addr,he->h_addr,sizeof(ip.s_addr)); + m_IP = ip.s_addr; + } + pICMP = CICMP::CreateICMP(); + if(!(pICMP && pICMP->Initialize())){ + m_Status.LoadString(IDS_PS_UNABLETOICMP); + break; + } + m_Daddy->PostMessage(WM_DNP_UPDATEHOSTDATA,0,(LPARAM)this); + ULONG sum, num, pmin, pmax; + sum = num = 0; + pmin = 0xFFFFFFFF; + pmax = 0; + UINT seq; + for(seq = 0;seqm_PingsPerHost;seq++){ + INT status; + LONG rtt = pICMP->Ping(ip,dataSize,m_Daddy->m_TimeOut,&status); + UINT stString = 0; + switch(status){ + case CICMP::ipSuccess: + sum+=rtt; num++; + if(rttpmax) + pmax=rtt; + break; + case CICMP::ipBuffTooSmall: stString = IDS_PS_INTERNALERROR; + break; + case CICMP::ipDestNetUnreachable: stString = IDS_PS_NETUNREACHABLE; + break; + case CICMP::ipDestHostUnreachable: stString = IDS_PS_HOSTUNREACHABLE; + break; + case CICMP::ipDestProtUnreachable: stString = IDS_PS_PROTUNREACHABLE; + break; + case CICMP::ipDestPortUnreachable: stString = IDS_PS_PORTUNREACHABLE; + break; + case CICMP::ipNoResources: stString = IDS_PS_NORESOURCES; + break; + case CICMP::ipBadOption: stString = IDS_PS_INTERNALERROR; + break; + case CICMP::ipHWError: stString = IDS_PS_HWERROR; + break; + case CICMP::ipPacketTooBig: stString = IDS_PS_BIGPACKET; + break; + case CICMP::ipTimeOut: stString = IDS_PS_TIMEOUT; + break; + case CICMP::ipBadRequest: stString = IDS_PS_INTERNALERROR; + break; + case CICMP::ipBadRoute: stString = IDS_PS_BADROUTE; + break; + case CICMP::ipTTLExpiredInTransit: stString = IDS_PS_TTLEXPTRANSIT; + break; + case CICMP::ipTTLExpiredInReasm: stString = IDS_PS_TTLEXPREASM; + break; + case CICMP::ipParamProblem: stString = IDS_PS_IPARAMP; + break; + case CICMP::ipSourceQuench: stString = IDS_PS_SOURCEQUENCH; + break; + case CICMP::ipOptionTooBig: stString = IDS_PS_BIGOPTION; + break; + case CICMP::ipBadDest: stString = IDS_PS_BADDEST; + break; + default: + stString = IDS_PS_UNKNOWNERROR; + break; + } + if(stString) + m_Status.LoadString(stString); + packets++; + if(rtt<0) + lost++; + Sleep(m_Daddy->m_Interval); + } + if(packets==lost || !packets){ + ploss=100; + }else{ + ploss = lost*100/packets; + m_MinRTT = pmin; + m_MaxRTT = pmax; + if(sum){ + ASSERT(num); + m_AvgRTT = sum/num; + }else{ + m_AvgRTT = 0; + } + } + }while(FALSE); + m_Packetloss=ploss; + m_Pinged=TRUE; + m_Pinging=FALSE; + if(pICMP){ + pICMP->Deinitialize(); + delete pICMP; + } + m_Daddy->PostMessage(WM_DNP_UPDATEHOSTDATA,0,(LPARAM)this); + m_Daddy->PostMessage(WM_DNP_ACTIVITYCOUNT,(WPARAM)-1); + return 0; +} + +void CPingyHost::Ping() +{ + ASSERT(m_Daddy); + m_Daddy->m_eveStartup.ResetEvent(); + if(!AfxBeginThread(CPingyHost::PingProc,this)){ + ASSERT(FALSE); + }else{ + CSingleLock sl(&m_Daddy->m_eveStartup); + sl.Lock(); + m_Daddy->SendMessage(WM_DNP_ACTIVITYCOUNT,(WPARAM)1); // *** AWFUL! Shouldn't be here! + } +} + +void CDipstickDlg::OnHostlistCopyurl() +{ + if(m_HostList.GetSelectedCount()!=1) + return; +int items = m_HostList.GetItemCount(); + for(int tmp=0;tmpm_URL.IsEmpty()){ + CURLSource *us = new CURLSource(host->m_URL); + us->SetClipboard(); + us->FlushClipboard(); + } +} + +BOOL CDipstickDlg::OnHelpInfo(HELPINFO* pHelpInfo) +{ + WinHelp(IDD|0x20000l); + return TRUE; +} + +void CDipstickDlg::OnDropFiles(HDROP hDropInfo) +{ + // *** Import only 1st file, but maybe we should fall into prompt mode if multiple files are dropped. +CString fileName; +int bufferSize = DragQueryFile(hDropInfo,0,NULL,0); + DragQueryFile(hDropInfo,0,fileName.GetBuffer(bufferSize+2),bufferSize+1); + fileName.ReleaseBuffer(); + if(fileName.IsEmpty()) + CDialog::OnDropFiles(hDropInfo); + else + ImportLocations(fileName); +} + +BOOL CDipstickDlg::ImportLocations(LPCTSTR file) +{ +CString fileLine; +CString q; + try{ + CStdioFile f(file,CFile::modeRead|CFile::typeText|CFile::shareDenyWrite); + // *** Cleanup locations.. + while(f.ReadString(fileLine)){ + if(fileLine.IsEmpty()) + continue; + if(fileLine[0]=='\"' || fileLine[0]=='\''){ + TCHAR q = fileLine[0]; + fileLine=fileLine.Mid(1); + for(int tmp=0;tmp=0) + fileLine=fileLine.Left(co); + } + if(fileLine.IsEmpty()) + continue; + if(!fileLine.CompareNoCase("url")) + continue; + PostMessage(WM_DNP_URLPING,0,(LPARAM)new CString(fileLine)); + } + }catch(CException* e){ + e->Delete(); + TRACE0("Failed to import URLList file\n"); + return FALSE; + } + return TRUE; +} + +void CDipstickDlg::OnAdvanced() +{ +CRect rc; + m_AdvancedCtl.GetClientRect(rc); + m_AdvancedCtl.ClientToScreen(rc); +CMenu menus; + VERIFY(menus.LoadMenu(IDR_MENU)); +CMenu *popUp = menus.GetSubMenu(2); + ASSERT(popUp); + popUp->EnableMenuItem(ID_ADVANCED_EXPORTLIST,MF_BYCOMMAND|(m_HostList.GetItemCount()?MF_ENABLED:MF_GRAYED)); + popUp->TrackPopupMenu(TPM_CENTERALIGN|TPM_RIGHTBUTTON|TPM_LEFTBUTTON,(rc.left+rc.right)/2,rc.top,this); +} + +void CDipstickDlg::OnAdvancedExportlist() +{ +CString filter; + filter.LoadString(IDS_CSVFILTER); +CFileDialog cfd(FALSE,".csv",NULL,OFN_EXPLORER|OFN_HIDEREADONLY|OFN_PATHMUSTEXIST,filter,this); + if(!m_impexPath.IsEmpty()) + SetCurrentDirectory(m_impexPath); + if(cfd.DoModal()==IDOK){ + GetCurrentDirectory(2048,m_impexPath.GetBuffer(2048)); + m_impexPath.ReleaseBuffer(); + ExportLocations(cfd.GetPathName()); + } +} + +void CDipstickDlg::OnAdvancedImportlist() +{ +CString filter; + filter.LoadString(IDS_CSVFILTER); +CFileDialog cfd(TRUE,".csv",NULL,OFN_EXPLORER|OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST,filter,this); + if(!m_impexPath.IsEmpty()) + SetCurrentDirectory(m_impexPath); + if(cfd.DoModal()==IDOK){ + GetCurrentDirectory(2048,m_impexPath.GetBuffer(2048)); + m_impexPath.ReleaseBuffer(); + ImportLocations(cfd.GetPathName()); + } +} + +BOOL CDipstickDlg::ExportLocations(LPCTSTR file) +{ + try{ + CStdioFile f(file,CFile::modeCreate|CFile::modeWrite|CFile::typeText); + f.WriteString("URL,Host Name,IP Address, Min RTT,Avg RTT,Max RTT,Pktloss\n"); + POSITION p = m_Hosts.GetHeadPosition(); + while(p){ + CPingyHost *host = m_Hosts.GetNext(p); + ASSERT(host); + CString ph; + ph.Format("\"%s\",%s,%s,%lu,%lu,%lu,%d%%\n",host->m_URL,host->m_HostName,inet_ntoa(*(in_addr*)&host->m_IP), + host->m_MinRTT,host->m_AvgRTT,host->m_MaxRTT,host->m_Packetloss + ); + f.WriteString(ph); + } + f.Close(); + }catch(CException* e){ + TRACE0("Failed to export URLList\n"); + e->Delete(); + return FALSE; + } + return TRUE; +} + +void CDipstickDlg::OnDragpadAdvancedExportlist() +{ + OnAdvancedExportlist(); +} + +void CDipstickDlg::OnDragpadAdvancedImportlist() +{ + OnAdvancedImportlist(); +} + +void CPingyHost::Suicide() +{ +CSingleLock sl(&m_mutex); + if(sl.Lock(10)){ + sl.Unlock(); + delete this; + }else{ + if(!AfxBeginThread(CPingyHost::SuicideProc,this)) + ASSERT(FALSE); + } +} + +UINT CPingyHost::SuicideProc(LPVOID pParam) +{ +CPingyHost* pThis = (CPingyHost*)pParam; +CSingleLock sl(&pThis->m_mutex); + sl.Lock(); + VERIFY(sl.Unlock()); + delete pThis; + return 0; +} -- cgit v0.9.0.2