diff options
| author | Vadim Dashevskiy <watcherhd@gmail.com> | 2012-11-28 18:44:28 +0000 |
|---|---|---|
| committer | Vadim Dashevskiy <watcherhd@gmail.com> | 2012-11-28 18:44:28 +0000 |
| commit | 68fb5b69ea8403a3f9dcb70b3133eb10e1711000 (patch) | |
| tree | c4e4e81724c9ea80fe7f2558991bda699961bc11 | |
| parent | 80d65efb84ec7500cd02ca047d0177d642eb1871 (diff) | |
forgotten files
git-svn-id: http://svn.miranda-ng.org/main/trunk@2544 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c
29 files changed, 4881 insertions, 0 deletions
diff --git a/plugins/Ping/res/green.ico b/plugins/Ping/res/green.ico Binary files differnew file mode 100644 index 0000000000..82ce348616 --- /dev/null +++ b/plugins/Ping/res/green.ico diff --git a/plugins/Ping/res/grey.ico b/plugins/Ping/res/grey.ico Binary files differnew file mode 100644 index 0000000000..7b91f7a64d --- /dev/null +++ b/plugins/Ping/res/grey.ico diff --git a/plugins/Ping/res/ping.rc b/plugins/Ping/res/ping.rc new file mode 100644 index 0000000000..db3bc43e6a --- /dev/null +++ b/plugins/Ping/res/ping.rc @@ -0,0 +1,227 @@ +// Microsoft Visual C++ generated resource script.
+//
+#include "..\src\resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE
+BEGIN
+ "resource.h\0"
+END
+
+2 TEXTINCLUDE
+BEGIN
+ "#include ""afxres.h""\r\n"
+ "\0"
+END
+
+3 TEXTINCLUDE
+BEGIN
+ "\r\n"
+ "\0"
+END
+
+#endif // APSTUDIO_INVOKED
+
+#endif // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////
+// English (Australia) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENA)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_AUS
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON_DISABLED ICON "grey.ico"
+IDI_ICON_NOTRESPONDING ICON "red.ico"
+IDI_ICON_RESPONDING ICON "green.ico"
+IDI_ICON_TESTING ICON "yellow.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOGEX 0, 0, 303, 227
+STYLE DS_SETFONT | DS_FIXEDSYS | DS_CENTER | WS_CHILD
+EXSTYLE WS_EX_CONTROLPARENT
+FONT 8, "MS Shell Dlg", 0, 0, 0x1
+BEGIN
+ RTEXT "Delay between pings (secs):",IDC_STATIC,9,21,121,8
+ EDITTEXT IDC_PPM,135,18,40,12,ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER,WS_EX_RIGHT
+ CONTROL "Timeout",IDC_CHECKPOPUP,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,20,72,10
+ RTEXT "Ping timeout (secs):",IDC_STATIC,9,41,121,8
+ EDITTEXT IDC_PT,135,39,40,12,ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER,WS_EX_RIGHT
+ GROUPBOX "Logging",IDC_STATIC,4,165,293,55
+ CONTROL "Log to File",IDC_CHK_LOG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,39,178,69,10
+ LTEXT "Log Filename:",IDC_STATIC,14,198,56,8
+ EDITTEXT IDC_ED_FILENAME,74,195,158,14,ES_AUTOHSCROLL
+ GROUPBOX "Network",IDC_STATIC,4,5,205,72
+ GROUPBOX "PopUps",IDC_STATIC,218,5,79,72
+ CONTROL "Reply",IDC_CHECKPOPUP2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,36,72,10
+ CONTROL "Block Repetitions",IDC_CHK_BLOCK,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,60,72,10
+ PUSHBUTTON "View Log",IDC_BTN_VIEWLOG,238,176,54,14
+ PUSHBUTTON "Browse...",IDC_BTN_LOGBROWSE,238,194,54,16
+ GROUPBOX "Interface",IDC_STATIC,4,84,293,76
+ CONTROL "Do not change icon when testing",IDC_CHK_NOTESTICON,
+ "Button",BS_AUTOCHECKBOX | WS_TABSTOP,17,145,181,10
+ LTEXT "Use the Customize/Fonts options to change text size and colour.",IDC_STATFS,20,101,174,18
+ RTEXT "Indent:",IDC_STATIC,44,127,33,8
+ EDITTEXT IDC_EDIT1,89,124,33,15,ES_AUTOHSCROLL
+ CONTROL "Spin2",IDC_SP_INDENT,"msctls_updown32",UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_ARROWKEYS,121,124,12,15
+ RTEXT "Row height:",IDC_STATIC,154,127,52,8
+ EDITTEXT IDC_EDIT2,217,124,33,15,ES_AUTOHSCROLL
+ CONTROL "Spin3",IDC_SP_ROWHEIGHT,"msctls_updown32",UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_ARROWKEYS,250,124,12,15
+ RTEXT "Repeats for success/failure:",IDC_STATIC,9,60,121,8
+ EDITTEXT IDC_RPT,135,59,40,12,ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER,WS_EX_RIGHT
+ CONTROL "Attach to contact list",IDC_CHK_ATTACH,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,201,145,94,10
+ CONTROL "Use CSV format",IDC_CHK_LOGCSV,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,136,178,96,10
+END
+
+IDD_DIALOG2 DIALOGEX 0, 0, 285, 212
+STYLE DS_SETFONT | DS_FIXEDSYS | DS_CENTER | WS_CHILD
+EXSTYLE WS_EX_CONTROLPARENT
+FONT 8, "MS Shell Dlg", 0, 0, 0x1
+BEGIN
+ PUSHBUTTON "Add",IDC_BTN_DESTADD,30,172,38,15
+ LISTBOX IDC_LST_DEST,29,32,228,128,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+ PUSHBUTTON "Remove",IDC_BTN_DESTREM,124,172,38,15,WS_DISABLED
+ PUSHBUTTON "Edit",IDC_BTN_DESTEDIT,77,172,38,15,WS_DISABLED
+ PUSHBUTTON "Up",IDC_BTN_DESTUP,171,172,38,15,WS_DISABLED
+ PUSHBUTTON "Down",IDC_BTN_DESTDOWN,218,172,38,15,WS_DISABLED
+END
+
+IDD_DIALOG3 DIALOGEX 0, 0, 263, 291
+STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Edit Host"
+FONT 8, "MS Shell Dlg", 0, 0, 0x1
+BEGIN
+ DEFPUSHBUTTON "OK",IDOK,78,270,50,14
+ PUSHBUTTON "Cancel",IDCANCEL,134,270,50,14
+ LTEXT "Address:",IDC_STATIC,24,34,37,8
+ LTEXT "Label:",IDC_STATIC,31,49,30,8
+ EDITTEXT IDC_ED_DESTADDR,67,30,154,12,ES_AUTOHSCROLL | ES_WANTRETURN
+ EDITTEXT IDC_ED_DESTLAB,67,48,154,12,ES_AUTOHSCROLL | ES_WANTRETURN
+ CONTROL "TCP Connect",IDC_CHK_DESTTCP,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,72,69,71,10
+ LTEXT "Port:",IDC_STATIC,151,69,25,8
+ EDITTEXT IDC_ED_DESTPORT,181,66,40,12,ES_RIGHT | ES_AUTOHSCROLL | ES_WANTRETURN | ES_NUMBER | WS_DISABLED
+ CTEXT "Control Protocol:",IDC_STATIC,84,106,92,8
+ COMBOBOX IDC_COMBO_DESTPROTO,83,119,97,30,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ COMBOBOX IDC_COMBO_DESTSTAT,156,158,76,30,CBS_DROPDOWNLIST | WS_DISABLED | WS_VSCROLL | WS_TABSTOP
+ LTEXT "Set my status to:",IDC_STATIC,151,143,87,8
+ LTEXT "On success, if my status is:",IDC_STATIC,25,143,115,8
+ COMBOBOX IDC_COMBO_DESTSTAT2,33,158,90,30,CBS_DROPDOWNLIST | WS_DISABLED | WS_VSCROLL | WS_TABSTOP
+ EDITTEXT IDC_ED_COMMAND,34,197,195,14,ES_AUTOHSCROLL
+ CTEXT "Execute the following command on double-click:",IDC_STATIC,28,182,207,8
+ GROUPBOX "Contact",IDC_STATIC,7,7,249,86
+ GROUPBOX "Protocols",IDC_STATIC,7,97,249,166
+ EDITTEXT IDC_ED_PARAMS,33,236,195,14,ES_AUTOHSCROLL
+ CTEXT "(Optional) Command Parameters:",IDC_STATIC,27,219,207,8
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO
+BEGIN
+ IDD_DIALOG1, DIALOG
+ BEGIN
+ LEFTMARGIN, 4
+ RIGHTMARGIN, 297
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 220
+ END
+
+ IDD_DIALOG2, DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 278
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 205
+ END
+
+ IDD_DIALOG3, DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 256
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 284
+ END
+END
+#endif // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MENU1 MENU
+BEGIN
+ POPUP "Menu"
+ BEGIN
+ MENUITEM "Graph", ID_MENU_GRAPH
+ MENUITEM "Enable", ID_MENU_TOGGLE
+ MENUITEM "Edit", ID_MENU_EDIT
+ MENUITEM SEPARATOR
+ MENUITEM "Disable all pings", ID_MENU_DISABLEALLPINGS
+ MENUITEM "Enable all pings", ID_MENU_ENABLEALLPINGS
+ MENUITEM SEPARATOR
+ MENUITEM "Options...", ID_MENU_OPTIONS
+ MENUITEM "Hosts...", ID_MENU_DESTINATIONS
+ END
+END
+
+#endif // English (Australia) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif // not APSTUDIO_INVOKED
+
diff --git a/plugins/Ping/res/red.ico b/plugins/Ping/res/red.ico Binary files differnew file mode 100644 index 0000000000..9c0c7c5a77 --- /dev/null +++ b/plugins/Ping/res/red.ico diff --git a/plugins/Ping/res/yellow.ico b/plugins/Ping/res/yellow.ico Binary files differnew file mode 100644 index 0000000000..94f62a201d --- /dev/null +++ b/plugins/Ping/res/yellow.ico diff --git a/plugins/Ping/src/collection.h b/plugins/Ping/src/collection.h new file mode 100644 index 0000000000..f8709e3ef8 --- /dev/null +++ b/plugins/Ping/src/collection.h @@ -0,0 +1,834 @@ +#include <malloc.h>
+
+template<class T> class Collection {
+protected:
+ unsigned long count;
+public:
+ Collection(): count(0) {}
+
+ virtual void clear() = 0;
+ virtual void add(const T &val) = 0;
+ virtual const bool remove(const T &val) = 0;
+
+ const unsigned long size() const {return count;}
+};
+
+template<class T> class Node {
+public:
+ T val;
+
+ Node(const T &v): val(v) {}
+ virtual ~Node() {}
+};
+
+template<class T> class ListNode: public Node<T> {
+public:
+ ListNode<T> *next, *prev;
+
+ ListNode(const T &v): Node<T>(v), next(0), prev(0) {}
+ virtual ~ListNode() {
+ if(next) next->prev = prev;
+ if(prev) prev->next = next;
+ }
+};
+
+template<class T> class LinkedList: public Collection<T> {
+protected:
+ ListNode<T> *head, *tail;
+
+public:
+ class Iterator {
+ friend class LinkedList<T>;
+ protected:
+ ListNode<T> *n;
+ Iterator(ListNode<T> *start): n(start) {}
+ public:
+ Iterator(const Iterator &other): n(other.n) {}
+
+ virtual T &val() {return n->val;}
+ virtual void next() {if(n) n = n->next;}
+ virtual void prev() {if(n) n = n->prev;}
+ virtual const bool has_val() {return (n ? true : false); }
+ };
+
+ LinkedList(): Collection<T>(), head(0), tail(0) {};
+ LinkedList(const LinkedList<T> &other): Collection<T>(), head(0), tail(0) {
+ for(Iterator i = other.start(); i.has_val(); i.next())
+ add(i.val());
+ }
+ virtual ~LinkedList() {clear();}
+
+ LinkedList<T> &operator=(const LinkedList<T> &other) {
+ clear();
+ for(Iterator i = other.start(); i.has_val(); i.next())
+ add(i.val());
+ return *this;
+ }
+
+ virtual void clear() {
+ ListNode<T> *n;
+ while(head) {
+ n = head;
+ head = head->next;
+ delete n;
+ }
+ tail = 0;
+ Collection<T>::count = 0;
+ }
+
+ virtual Iterator start() const {return Iterator(head);}
+
+ virtual void add_front(T &val) {
+ ListNode<T> *n = new ListNode<T>(val);
+ n->next = head;
+ if(head) head->prev = n;
+ head = n;
+ if(!tail) tail = n;
+ Collection<T>::count++;
+ }
+
+ virtual void add(const T &val) {
+ ListNode<T> *n = new ListNode<T>(val);
+ n->prev = tail;
+ if(tail) tail->next = n;
+ tail = n;
+ if(!head) head = n;
+ Collection<T>::count++;
+ }
+
+ virtual const bool remove(const T &val) {
+ ListNode<T> *n = head;
+ while(n) {
+ if(n->val == val) {
+ if(n == head) head = head->next;
+ if(n == tail) tail = tail->prev;
+
+ delete n;
+ Collection<T>::count--;
+ return true;
+ } else
+ n = n->next;
+ }
+
+ return false;
+ }
+
+ virtual const bool contains(T &val) const {
+ ListNode<T> *n = head;
+ while(n) {
+ if(n->val == val) {
+ return true;
+ } else
+ n = n->next;
+ }
+
+ return false;
+ }
+
+ // queue/stack functions
+ // stack - use push/pop
+ // queue - use push_back/pop
+ virtual void push(T val) {
+ add_front(val);
+ }
+
+ virtual void push_back(T &val) {
+ add(val);
+ }
+
+ virtual const bool pop(T &val) {
+ if(!head) return false;
+
+ ListNode<T> *n = head;
+ if(head) {
+ head = head->next;
+ if(n == tail) tail = 0;
+ val = n->val;
+ delete n;
+ Collection<T>::count--;
+ return true;
+ } else
+ return false;
+ }
+};
+
+template<class T> class DynamicArray: public Collection<T> {
+protected:
+ T *ar;
+
+ unsigned long initial, limit, increment;
+
+public:
+ class Iterator {
+ friend class DynamicArray<T>;
+ protected:
+ T *ar;
+ unsigned long count;
+ unsigned long pos;
+ Iterator(T *a, const int c, unsigned long p): ar(a), count(c), pos(p) {}
+ public:
+ Iterator(const Iterator &other): ar(other.ar), count(other.count), pos(other.pos) {}
+
+ virtual T &val() {return ar[pos];}
+ virtual void next() {pos++;}
+ virtual void prev() {pos--;}
+ virtual const bool has_val() {return pos < count; }
+ };
+
+ DynamicArray(unsigned long init = 0, unsigned long inc = 1): Collection<T>(), ar(0), initial(init), limit(init), increment(inc) {
+ if(limit) ar = (T *)malloc(limit * sizeof(T));
+ }
+ virtual ~DynamicArray() {if(ar) free(ar);}
+
+ virtual void clear() {
+ Collection<T>::count = 0;
+ limit = initial;
+ if(limit) ar = (T *)realloc(ar, limit * sizeof(T));
+ else {
+ free(ar);
+ ar = 0;
+ }
+ }
+
+ virtual Iterator start() const {return Iterator(ar, Collection<T>::count, 0);}
+
+ virtual void add(const T &val) {
+ if(Collection<T>::count == limit) {
+ limit += increment;
+ ar = (T *)realloc(ar, limit * sizeof(T));
+ ar[Collection<T>::count++] = val;
+ } else
+ ar[Collection<T>::count++] = val;
+ }
+
+ virtual void add_all(DynamicArray<T> &other) {
+ for(Iterator i = other.start(); i.has_val(); i.next()) {
+ add(i.val());
+ }
+ }
+
+ virtual const bool remove(const T &val) {
+ for(unsigned long i = 0; i < Collection<T>::count; i++) {
+ if(ar[i] == val) {
+ memmove(ar + i, ar + i + 1, (Collection<T>::count - i) * sizeof(T));
+ Collection<T>::count--;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ virtual const bool remove(const unsigned long index) {
+ if(index >= Collection<T>::count) return false;
+
+ memmove(ar + index, ar + index + 1, (Collection<T>::count - index) * sizeof(T));
+ Collection<T>::count--;
+ return true;
+ }
+
+ virtual const bool insert(const T &val, const unsigned long index) {
+ if(index > Collection<T>::count) return false;
+
+ if(Collection<T>::count == limit) {
+ limit += increment;
+ ar = (T *)realloc(ar, limit * sizeof(T));
+ }
+
+ if(index < Collection<T>::count)
+ memmove(ar + index + 1, ar + index, (Collection<T>::count - index) * sizeof(T));
+
+ ar[index] = val;
+ Collection<T>::count++;
+ return true;
+ }
+
+ virtual T &operator[](const int index) {
+ return ar[index];
+ }
+
+ const bool index_of(const T &val, unsigned long &index) const {
+ for(int i = 0; i < Collection<T>::count; i++) {
+ if(ar[index] == val) {
+ index = i;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ const int index_of(const T &val) const {
+ for(int i = 0; i < Collection<T>::count; i++) {
+ if(ar[i] == val) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ // stack functions
+ virtual const bool pop(T &val) {
+ if(Collection<T>::count) {
+ val = ar[Collection<T>::count -1];
+ remove(Collection<T>::count -1);
+ return true;
+ }
+ return false;
+ }
+
+ virtual void push(const T &val) {
+ add(val);
+ }
+};
+
+template<class T> class SortedDynamicArray: public DynamicArray<T> {
+public:
+ SortedDynamicArray(unsigned long init = 0, unsigned long inc = 1): DynamicArray<T>(init, inc) {}
+ virtual ~SortedDynamicArray() {}
+
+ const bool get_index(const T &val, unsigned long &index) {
+ unsigned long low = 0;
+ unsigned long high = Collection<T>::count-1;
+
+ while( high < Collection<T>::count && low <= high )
+ {
+ unsigned long i = ( low+high )/2;
+ if ( DynamicArray<T>::ar[i] == val )
+ { index = i;
+ return true;
+ } else
+ if (DynamicArray<T>::ar[i] < val)
+ low = i+1;
+ else
+ high = i-1;
+ }
+
+ index = low;
+ return false;
+ }
+
+ virtual void add(const T &val) {
+ unsigned long index;
+ get_index(val, index);
+ insert(val, index);
+ }
+};
+
+template<class T> class TreeNode: public Node<T> {
+public:
+ TreeNode<T> *parent, *left, *right;
+
+ TreeNode(const T &v, TreeNode<T> *par): Node<T>(v), parent(par), left(0), right(0) {}
+ virtual ~TreeNode() {
+ if(parent) {
+ if(parent->left == this) parent->left = 0;
+ if(parent->right == this)parent->right = 0;
+ }
+ }
+};
+
+template<class T, class N = TreeNode<T> > class BinaryTree: public Collection<T> {
+protected:
+
+ N *root;
+
+ virtual void delete_node(N *n) {
+ if(n->left && n->right) {
+ N *minmax = n->left;
+ while(minmax->right) minmax = minmax->right;
+ n->val = minmax->val;
+ delete_node(minmax);
+ return;
+ } else if(n->right) {
+ if(n->parent) {
+ if(n->parent->left == n) n->parent->left = n->right;
+ else n->parent->right = n->right;
+ } else
+ root = n->right;
+ n->right->parent = n->parent;
+ } else if(n->left) {
+ if(n->parent) {
+ if(n->parent->left == n) n->parent->left = n->left;
+ else n->parent->right = n->left;
+ } else
+ root = n->left;
+ n->left->parent = n->parent;
+ } else {
+ if(n == root) root = 0;
+ }
+ delete n;
+ Collection<T>::count--;
+ }
+
+ virtual void insert_node(N *n) {
+ N *current = root, *parent = 0;
+ while(current) {
+ parent = current;
+ if(n->val < current->val)
+ current = current->left;
+ else
+ current = current->right;
+ }
+
+ if(parent) {
+ if(n->val < parent->val) {
+ parent->left = n;
+ } else {
+ parent->right = n;
+ }
+ } else
+ root = n;
+
+ n->parent = parent;
+ Collection<T>::count++;
+ }
+
+public:
+ class Iterator {
+ friend class BinaryTree<T, N>;
+ protected:
+
+ class EvalNode {
+ public:
+ bool evaluate;
+ N *node;
+
+ EvalNode(): evaluate(false), node(0) {}
+ EvalNode(const bool eval, N *n): evaluate(eval), node(n) {}
+ const bool operator==(const EvalNode &other) const {return node == other.node;}
+ EvalNode &operator=(const EvalNode &other) {evaluate = other.evaluate; node = other.node; return *this;}
+
+ };
+
+ N *n;
+ LinkedList<EvalNode> stack;
+
+
+ Iterator(N *start): n(0) {
+ if(start) {
+ stack.push(EvalNode(true, start));
+ next();
+ }
+ }
+
+ public:
+ Iterator(const Iterator &other):n(other.n), stack(other.stack) {}
+ virtual ~Iterator() {}
+
+ virtual T &val() {return n->val;}
+ virtual void next() {
+ EvalNode en;
+ bool popped = false;
+ while((popped = stack.pop(en)) && en.evaluate) {
+ if(en.node->right) stack.push(EvalNode(true, en.node->right));
+ stack.push(EvalNode(false, en.node));
+ if(en.node->left) stack.push(EvalNode(true, en.node->left));
+ }
+
+ n = (popped ? en.node : 0);
+ }
+ virtual const bool has_val() {return (n ? true : false);}
+ };
+
+ BinaryTree(): Collection<T>(), root(0) {};
+ BinaryTree(BinaryTree<T> &other): Collection<T>(), root(0) {
+ for(Iterator i = other.start(); i.has_val(); i.next())
+ add(i.val());
+ }
+ virtual ~BinaryTree() {clear();}
+
+ BinaryTree &operator=(BinaryTree<T> &other) {
+ clear();
+ for(Iterator i = other.start(); i.has_val(); i.next())
+ add(i.val());
+ return *this;
+ }
+
+ virtual void clear() {
+ N *current = root, *parent = 0;
+ while(current) {
+ if(current->left) current = current->left;
+ else if(current->right) current = current->right;
+ else {
+ parent = current->parent;
+ delete current;
+ current = parent;
+ }
+ }
+
+ root = 0;
+ Collection<T>::count = 0;
+ }
+
+ void add(const T &val) {
+ N *n = new N(val, 0);
+ insert_node(n);
+ }
+
+ const bool remove(const T &val) {
+ N *current = root;
+ while(current) {
+ if(current->val == val)
+ break;
+ else if(val < current->val)
+ current = current->left;
+ else
+ current = current->right;
+ }
+
+ if(current) {
+ delete_node(current);
+ return true;
+ }
+
+ return false;
+ }
+
+ const bool contains(const T &val) const {
+ N *current = root;
+ while(current) {
+ if(current->val == val)
+ break;
+ else if(val < current->val)
+ current = current->left;
+ else
+ current = current->right;
+ }
+
+ return current != 0;
+ }
+
+ Iterator start() const {return Iterator(root);}
+};
+
+#define RED 1
+#define BLACK 0
+
+// thanks to wikipedia (http://en.wikipedia.org/wiki/Red_black_tree)
+template<class T> class ColouredTreeNode: public Node<T> {
+public:
+ ColouredTreeNode<T> *parent, *left, *right;
+ char color;
+
+ ColouredTreeNode(const T &v, ColouredTreeNode<T> *par): Node<T>(v), parent(par), left(0), right(0), color(BLACK) {}
+ virtual ~ColouredTreeNode() {
+ if(parent) {
+ if(parent->left == this) parent->left = 0;
+ if(parent->right == this)parent->right = 0;
+ }
+ }
+};
+
+template<class T, class N = ColouredTreeNode<T> > class RedBlackTree: public BinaryTree<T, N> {
+protected:
+ N *grandparent(N *n) {
+ if (n && n->parent)
+ return n->parent->parent;
+ else
+ return NULL;
+ }
+ N *uncle(N *n) {
+ if(grandparent(n)) {
+ if (n->parent == grandparent(n)->left)
+ return grandparent(n)->right;
+ else
+ return grandparent(n)->left;
+ } else
+ return NULL;
+ }
+ N *sibling(N *n) {
+ if(n->parent) {
+ if (n == n->parent->left)
+ return n->parent->right;
+ else
+ return n->parent->left;
+ } else
+ return NULL;
+ }
+ bool is_leaf(N *n) {
+ return n == 0;
+ }
+
+ void replace_node(N *o, N *n) {
+ n->parent = o->parent;
+ if(n->parent) {
+ if(n->parent->left == o) n->parent->left = n;
+ else if(n->parent->right == o) n->parent->right = n;
+ } else
+ BinaryTree<T, N>::root = n;
+ }
+
+ void rotate_left(N *n) {
+ N *p = n->right;
+ N *q = n;
+
+ q->right = p->left;
+ if(q->right) q->right->parent = q;
+ p->left = q;
+ p->parent = q->parent;
+ q->parent = p;
+ if(p->parent) {
+ if(p->parent->left == q) p->parent->left = p;
+ else if(p->parent->right == q) p->parent->right = p;
+ } else
+ BinaryTree<T, N>::root = p;
+ }
+ void rotate_right(N *n) {
+ N *p = n->left;
+ N *q = n;
+
+ q->left = p->right;
+ if(q->left) q->left->parent = q;
+ p->right = q;
+ p->parent = q->parent;
+ q->parent = p;
+ if(p->parent) {
+ if(p->parent->left == q) p->parent->left = p;
+ else if(p->parent->right == q) p->parent->right = p;
+ } else
+ BinaryTree<T, N>::root = p;
+ }
+
+ void insert_case1(N *n) {
+ if (n->parent == NULL)
+ n->color = BLACK;
+ else
+ insert_case2(n);
+ }
+ void insert_case2(N *n) {
+ if (n->parent->color == BLACK)
+ return; /* Tree is still valid */
+ else
+ insert_case3(n);
+ }
+ void insert_case3(N *n) {
+ if (uncle(n) != NULL && uncle(n)->color == RED) {
+ n->parent->color = BLACK;
+ uncle(n)->color = BLACK;
+ grandparent(n)->color = RED;
+ insert_case1(grandparent(n));
+ } else
+ insert_case4(n);
+ }
+ void insert_case4(N *n) {
+ if (n == n->parent->right && n->parent == grandparent(n)->left) {
+ rotate_left(n->parent);
+ n = n->left;
+ } else if (n == n->parent->left && n->parent == grandparent(n)->right) {
+ rotate_right(n->parent);
+ n = n->right;
+ }
+ insert_case5(n);
+ }
+ void insert_case5(N *n) {
+ n->parent->color = BLACK;
+ grandparent(n)->color = RED;
+ if (n == n->parent->left && n->parent == grandparent(n)->left) {
+ rotate_right(grandparent(n));
+ } else {
+ /* Here, n == n->parent->right && n->parent == grandparent(n)->right */
+ rotate_left(grandparent(n));
+ }
+ }
+
+ void delete_case0(N *n) {
+ /* Precondition: n has at most one non-null child */
+ N *child = is_leaf(n->right) ? n->left : n->right;
+ if(child) replace_node(n, child);
+ if (n->color == BLACK) {
+ if(child) {
+ if (child->color == RED)
+ child->color = BLACK;
+ else
+ delete_case1(child);
+ } else
+ delete_case1(n);
+ }
+ if(BinaryTree<T, N>::root == n) BinaryTree<T, N>::root = 0;
+ delete n;
+ Collection<T>::count--;
+ }
+ void delete_case1(N *n) {
+ if (n->parent == NULL)
+ return;
+ else
+ delete_case2(n);
+ }
+ void delete_case2(N *n) {
+ if (sibling(n) && sibling(n)->color == RED) {
+ n->parent->color = RED;
+ sibling(n)->color = BLACK;
+ if (n == n->parent->left)
+ rotate_left(n->parent);
+ else
+ rotate_right(n->parent);
+ }
+ delete_case3(n);
+ }
+ void delete_case3(N *n) {
+ if (n->parent->color == BLACK &&
+ sibling(n) &&
+ sibling(n)->color == BLACK &&
+ (sibling(n)->left == 0 || sibling(n)->left->color == BLACK) &&
+ (sibling(n)->right == 0 || sibling(n)->right->color == BLACK))
+ {
+ sibling(n)->color = RED;
+ delete_case1(n->parent);
+ } else
+ delete_case4(n);
+ }
+ void delete_case4(N *n) {
+ if (n->parent->color == RED &&
+ sibling(n) &&
+ sibling(n)->color == BLACK &&
+ (sibling(n)->left == 0 || sibling(n)->left->color == BLACK) &&
+ (sibling(n)->right == 0 || sibling(n)->right->color == BLACK))
+ {
+ sibling(n)->color = RED;
+ n->parent->color = BLACK;
+ } else
+ delete_case5(n);
+ }
+ void delete_case5(N *n) {
+ if (n == n->parent->left &&
+ sibling(n) &&
+ sibling(n)->color == BLACK &&
+ sibling(n)->left &&
+ sibling(n)->left->color == RED &&
+ (sibling(n)->right == 0 || sibling(n)->right->color == BLACK))
+ {
+ sibling(n)->color = RED;
+ sibling(n)->left->color = BLACK;
+ rotate_right(sibling(n));
+ } else if (n == n->parent->right &&
+ sibling(n) &&
+ sibling(n)->color == BLACK &&
+ sibling(n)->right &&
+ sibling(n)->right->color == RED &&
+ (sibling(n)->left == 0 || sibling(n)->left->color == BLACK))
+ {
+ sibling(n)->color = RED;
+ sibling(n)->right->color = BLACK;
+ rotate_left(sibling(n));
+ }
+ delete_case6(n);
+ }
+ void delete_case6(N *n) {
+ sibling(n)->color = n->parent->color;
+ n->parent->color = BLACK;
+ if (n == n->parent->left) {
+ /* Here, sibling(n)->right->color == RED */
+ sibling(n)->right->color = BLACK;
+ rotate_left(n->parent);
+ } else {
+ /* Here, sibling(n)->left->color == RED */
+ sibling(n)->left->color = BLACK;
+ rotate_right(n->parent);
+ }
+ }
+
+ N *get_predecessor(N *n) {
+ N *minmax = n->left;
+ while(minmax->right) minmax = minmax->right;
+ return minmax;
+ }
+
+ virtual void insert_node(N *n) {
+ BinaryTree<T, N>::insert_node(n);
+ n->color = RED;
+
+ insert_case1(n);
+ }
+
+ virtual void delete_node(N *n) {
+ if(n->left && n->right) {
+ N *predecessor = get_predecessor(n);
+ n->val = predecessor->val;
+ delete_case0(predecessor);
+ } else
+ delete_case0(n);
+ }
+
+public:
+ RedBlackTree(): BinaryTree< T, N >() {}
+ virtual ~RedBlackTree() {}
+};
+
+template<class A, class B> class Pair {
+public:
+ A first;
+ B second;
+
+ Pair(const A &f): first(f) {}
+ Pair(const A &f, const B &s): first(f), second(s) {}
+ Pair(const Pair<A,B> &other): first(other.first), second(other.second) {}
+ virtual ~Pair() {}
+
+ const bool operator<(const Pair<A,B> &other) const {return first < other.first;}
+ const bool operator==(const Pair<A,B> &other) const {return first == other.first;}
+ Pair<A,B> &operator=(const Pair<A,B> &other) {first = other.first; second = other.second; return *this;}
+};
+
+//template<class A, class B, class N = TreeNode<Pair<A, B> > > class Map: public BinaryTree< Pair< A, B >, N > {
+template<class A, class B, class N = ColouredTreeNode<Pair<A, B> > > class Map: public RedBlackTree< Pair< A, B >, N > {
+protected:
+
+ N *find(A &key) const {
+ N *n = RedBlackTree< Pair< A, B >, N >::root;
+ while(n) {
+ if(n->val.first == key)
+ return n;
+ else if(key < n->val.first)
+ n = n->left;
+ else
+ n = n->right;
+
+ }
+ return 0;
+ }
+public:
+ //Map(): BinaryTree< Pair<A,B>, N >() {}
+ Map(): RedBlackTree< Pair<A,B>, N >() {}
+ virtual ~Map() {}
+
+ void put(A &key, B &value) {
+ add(Pair<A,B>(key, value));
+ }
+
+ const bool get(A &key, B &val) const {
+ const N *n = find(key);
+ if(n) {
+ val = n->val.second;
+ return true;
+ } else
+ return false;
+ }
+
+ B &operator[](A &key) {
+ N *n = find(key);
+ if(n)
+ return n->val.second;
+ else {
+ Pair< A, B > p(key);
+ N *n = new N(p, 0);
+ insert_node(n);
+ return n->val.second;
+ }
+ }
+
+ virtual const bool exists(A &key) const {
+ const N *n = find(key);
+ if(n) {
+ return true;
+ } else
+ return false;
+ }
+
+ virtual const bool remove(A &key) {
+ N *n = find(key);
+ if(n) {
+ delete_node(n);
+ return true;
+ } else
+ return false;
+ }
+};
diff --git a/plugins/Ping/src/common.h b/plugins/Ping/src/common.h new file mode 100644 index 0000000000..cc014898e1 --- /dev/null +++ b/plugins/Ping/src/common.h @@ -0,0 +1,125 @@ +#ifndef _COMMON_H
+#define _COMMON_H
+
+#define MAX_HISTORY (1440) // 12 hrs at 30 sec intervals
+
+#define PLUG "PING"
+
+#define DEFAULT_PING_PERIOD 30
+#define DEFAULT_PING_TIMEOUT 2
+#define DEFAULT_SHOW_POPUP true
+#define DEFAULT_SHOW_POPUP2 false
+#define DEFAULT_BLOCK_REPS true
+#define DEFAULT_LOGGING_ENABLED false
+#define DEFAULT_LOG_FILENAME "ping_log.txt"
+#define DEFAULT_NO_TEST_ICON true
+#define DEFAULT_ATTACH_TO_CLIST false
+
+#define MAX_PINGADDRESS_STRING_LENGTH 256
+
+//#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+//#define VC_EXTRALEAN
+//#define _WIN32_WINNT 0x0500
+
+#define WINVER 0x0500
+#define _WIN32_WINNT 0x0500
+#define _WIN32_IE 0x0300
+
+#define MIRANDA_VER 0x0600
+#include <windows.h>
+
+//#include <prsht.h>
+#include <shellapi.h>
+#include <commdlg.h>
+#include <commctrl.h>
+#include <time.h>
+
+#include <stdio.h>
+
+#include <newpluginapi.h>
+#include <statusmodes.h>
+#include <m_options.h>
+#include <m_langpack.h>
+#include <m_popup.h>
+#include <m_system.h>
+#include <m_skin.h>
+#include <m_netlib.h>
+#include <m_database.h>
+#include <m_protocols.h>
+#include <m_protomod.h>
+#include <m_protosvc.h>
+#include <m_ignore.h>
+#include <m_clist.h>
+#include <m_clui.h>
+#include <m_genmenu.h>
+#include <m_cluiframes.h>
+#include <m_utils.h>
+#include <m_fontservice.h>
+#include <m_icolib.h>
+
+
+#include "collection.h"
+
+typedef struct {
+ int ping_period, ping_timeout;
+ bool show_popup, show_popup2, block_reps, logging;
+ char log_filename[MAX_PATH];
+ bool no_test_icon;
+ int row_height;
+ int indent;
+ int retries;
+ bool attach_to_clist;
+ bool log_csv;
+} PingOptions;
+
+#pragma warning( disable : 4786 )
+
+// a deque of pairs - ping time and timestamp
+struct HistPair {
+ short first;
+ time_t second;
+
+ const bool operator==(const HistPair &other) const {return first == other.first && second == other.second;}
+};
+typedef LinkedList< HistPair > HistoryList;
+
+
+#define PS_RESPONDING 1
+#define PS_NOTRESPONDING 2
+#define PS_TESTING 3
+#define PS_DISABLED 4
+
+struct PINGADDRESS {
+ int cbSize; //size in bytes of this structure
+ DWORD item_id;
+ char pszName[MAX_PINGADDRESS_STRING_LENGTH]; //IP address or domain name
+ char pszLabel[MAX_PINGADDRESS_STRING_LENGTH];
+ bool responding;
+ int status;
+ short round_trip_time;
+ int miss_count;
+ int port; // -1 for ICMP, non-zero for TCP
+ char pszProto[MAX_PINGADDRESS_STRING_LENGTH];
+ char pszCommand[MAX_PATH];
+ char pszParams[MAX_PATH];
+ unsigned int get_status; // on success, if status equals this
+ unsigned int set_status; // set it to this
+ int index;
+
+ const bool operator==(const PINGADDRESS &b) const;
+ const bool operator<(const PINGADDRESS &b) const;
+};
+
+typedef Map<DWORD, HistoryList> HistoryMap;
+
+
+extern HANDLE hNetlibUser;
+extern HINSTANCE hInst;
+
+extern bool use_raw_ping;
+
+#ifndef MIID_PING
+#define MIID_PING {0x9cd1684e, 0xc520, 0x4b58, { 0x9a, 0x52, 0xae, 0x3d, 0x7a, 0x72, 0x4, 0x46}}
+#endif
+
+#endif
diff --git a/plugins/Ping/src/icmp.cpp b/plugins/Ping/src/icmp.cpp new file mode 100644 index 0000000000..af9a3605e4 --- /dev/null +++ b/plugins/Ping/src/icmp.cpp @@ -0,0 +1,117 @@ +#include "common.h"
+#include "icmp.h"
+
+char data[] = "AAAABBBBCCCCDDDDEEEEFFFFGGGGHHH";
+ICMP *ICMP::instance = 0;
+
+#define BUFFER_SIZE (8 * (sizeof(ICMP_ECHO_REPLY) + sizeof(data)))
+
+ICMP::ICMP():
+ timeout(2000),
+ functions_loaded(false)
+{
+ hDLL = LoadLibrary(_T("IPHLPAPI.DLL"));
+ if(hDLL) {
+ pIcmpCreateFile = (pfnHV)GetProcAddress(hDLL, "IcmpCreateFile");
+ pIcmpCloseHandle = (pfnBH)GetProcAddress(hDLL, "IcmpCloseHandle");
+ pIcmpSendEcho2 = (pfnDHDPWPipPDD)GetProcAddress(hDLL, "IcmpSendEcho2");
+ }
+ if (hDLL == 0 || pIcmpCreateFile == 0 || pIcmpCloseHandle == 0 || pIcmpSendEcho2 == 0) {
+ hDLL = LoadLibrary(_T("ICMP.DLL"));
+ if(hDLL) {
+ pIcmpCreateFile = (pfnHV)GetProcAddress(hDLL, "IcmpCreateFile");
+ pIcmpCloseHandle = (pfnBH)GetProcAddress(hDLL, "IcmpCloseHandle");
+ pIcmpSendEcho2 = (pfnDHDPWPipPDD)GetProcAddress(hDLL, "IcmpSendEcho2");
+ }
+ if (hDLL == 0 || pIcmpCreateFile == 0 || pIcmpCloseHandle == 0 || pIcmpSendEcho2 == 0)
+ return;
+ else
+ DBWriteContactSettingString(0, PLUG, "PingLib", "ICMP.DLL"); // for debugging
+ } else
+ DBWriteContactSettingString(0, PLUG, "PingLib", "IPHLPAPI.DLL"); // for debugging
+
+ WSAData wsaData;
+ if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) {
+ WSACleanup();
+ FreeLibrary((HMODULE)hDLL);
+ return;
+ }
+
+ /*
+ hIP = pIcmpCreateFile();
+ if (hIP == INVALID_HANDLE_VALUE) {
+ pIcmpCloseHandle(hIP);
+ return;
+ }
+ */
+
+ buff = new char[BUFFER_SIZE];
+ functions_loaded = true;
+}
+
+void ICMP::stop() {
+ //if(hIP) {
+ // pIcmpCloseHandle(hIP);
+ // hIP = 0;
+ //}
+}
+
+ICMP::~ICMP() {
+ if(hIP) stop();
+ WSACleanup();
+ if(hDLL)
+ FreeLibrary(hDLL);
+ delete[] buff;
+}
+
+bool ICMP::ping(char *host, ICMP_ECHO_REPLY &reply) {
+ if(!functions_loaded) return false;
+
+ HOSTENT *rec;
+ IP_OPTION_INFORMATION ipoi;
+
+ unsigned long address = inet_addr(host);
+ if (address == INADDR_NONE) {
+ rec = gethostbyname(host);
+ if(rec) address = *(unsigned long *)(*rec->h_addr_list);
+ else return false;
+ }
+
+ ipoi.Ttl = 255;
+ ipoi.Tos = 0;
+ ipoi.Flags = 0;
+ ipoi.OptionsSize = 0;
+ ipoi.OptionsData = 0;
+
+ reply.Status = 0;
+
+ hIP = pIcmpCreateFile();
+ if (hIP == INVALID_HANDLE_VALUE) return false;
+
+ //pIcmpSendEcho2(hIP, 0, 0, 0, address, data, sizeof(data), &ipoi, buff, sizeof(ICMP_ECHO_REPLY) + sizeof(data), timeout);
+ if(pIcmpSendEcho2(hIP, 0, 0, 0, address, data, sizeof(data), 0, buff, BUFFER_SIZE, timeout) == 0) {
+ DWORD code = GetLastError();
+ if(code != 11010) {
+ char winmsg[512], msg[1024];
+ FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, 0, code, 0, winmsg, 512, 0);
+ mir_snprintf(msg, 1024, "Ping error (%d): %s", code, winmsg);
+ PUShowMessage(msg, SM_NOTIFY);
+ return false;
+ }
+ }
+ memcpy(&reply, buff, sizeof(ICMP_ECHO_REPLY));
+
+ pIcmpCloseHandle(hIP);
+
+ return (reply.Status == 0);
+}
+
+ICMP *ICMP::get_instance() {
+ if(!instance)
+ instance = new ICMP();
+ return instance;
+}
+
+void ICMP::cleanup() {
+ if(instance) delete instance;
+}
\ No newline at end of file diff --git a/plugins/Ping/src/icmp.h b/plugins/Ping/src/icmp.h new file mode 100644 index 0000000000..984fd88fe9 --- /dev/null +++ b/plugins/Ping/src/icmp.h @@ -0,0 +1,71 @@ +// adapted 23/9/2004 from public domain code at http://tangentsoft.net/wskfaq/examples/dllping.html
+
+#ifndef _ICMP_H
+#define _ICMP_H
+
+//#include <windows.h>
+#include <iphlpapi.h>
+//#include <icmpapi.h>
+
+// Structures required to use functions in ICMP.DLL
+/*
+typedef struct {
+ unsigned char Ttl; // Time To Live
+ unsigned char Tos; // Type Of Service
+ unsigned char Flags; // IP header flags
+ unsigned char OptionsSize; // Size in bytes of options data
+ unsigned char *OptionsData; // Pointer to options data
+} IP_OPTION_INFORMATION, * PIP_OPTION_INFORMATION;
+
+typedef struct {
+ DWORD Address; // Replying address
+ unsigned long Status; // Reply status
+ unsigned long RoundTripTime; // RTT in milliseconds
+ unsigned short DataSize; // Echo data size
+ unsigned short Reserved; // Reserved for system use
+ void *Data; // Pointer to the echo data
+ IP_OPTION_INFORMATION Options; // Reply options
+ unsigned char ReplyData[8];
+} IP_ECHO_REPLY, * PIP_ECHO_REPLY;
+
+*/
+typedef HANDLE (WINAPI* pfnHV)(VOID);
+typedef BOOL (WINAPI* pfnBH)(HANDLE);
+typedef DWORD (WINAPI* pfnDHDPWPipPDD)(HANDLE, HANDLE, FARPROC, PVOID, IPAddr, LPVOID, WORD, PIP_OPTION_INFORMATION, LPVOID, DWORD, DWORD);
+
+class ICMP {
+protected:
+ pfnHV pIcmpCreateFile;
+ pfnBH pIcmpCloseHandle;
+ pfnDHDPWPipPDD pIcmpSendEcho2;
+
+ HMODULE hDLL;
+
+ HANDLE hIP;
+
+ unsigned int timeout;
+ bool functions_loaded;
+
+ // protected constructor - singleton class
+ ICMP();
+ static ICMP *instance;
+
+ char *buff;
+
+public:
+ ~ICMP();
+ static ICMP *get_instance();
+ static void cleanup();
+
+ bool ping(char *host, ICMP_ECHO_REPLY &reply);
+
+ void set_timeout(unsigned int t) {
+ timeout = t;
+ }
+
+ void stop();
+
+ unsigned int get_timeout() {return timeout;}
+
+};
+#endif //_ICMP_H
diff --git a/plugins/Ping/src/log.cpp b/plugins/Ping/src/log.cpp new file mode 100644 index 0000000000..de2889fde1 --- /dev/null +++ b/plugins/Ping/src/log.cpp @@ -0,0 +1,59 @@ +#include "common.h"
+#include "log.h"
+
+INT_PTR Log(WPARAM wParam, LPARAM lParam) {
+
+ TCHAR buf[1024], tbuf[512], dbuf[512];
+ CallService(PLUG "/GetLogFilename", (WPARAM)1024, (LPARAM)buf);
+
+ //char TBcapt[255];
+ SYSTEMTIME systime;
+
+ GetLocalTime(&systime);
+
+ GetTimeFormat(LOCALE_USER_DEFAULT, 0, &systime, 0, tbuf, 512);
+ GetDateFormat(LOCALE_USER_DEFAULT, 0, &systime, 0, dbuf, 512);
+
+ char *line = (char *)wParam;
+
+ FILE *f = _tfopen(buf, _T("a+"));
+ if(f) {
+ if(options.log_csv) {
+ fprintf(f, "%s, %s, %s\n", dbuf, tbuf, line);
+ } else {
+ fprintf(f, "%s, %s: %s\n", dbuf, tbuf, line);
+ }
+ fclose(f);
+ }
+
+ return 0;
+}
+
+INT_PTR GetLogFilename(WPARAM wParam, LPARAM lParam) {
+ DBVARIANT dbv;
+ char *filename = (char *)lParam;
+ if(DBGetContactSetting(0, PLUG, "LogFilename", &dbv)) {
+ CallService(MS_DB_GETPROFILEPATH, (WPARAM)wParam, (LPARAM)filename);
+ strcat(filename, "\\");
+ strcat(filename, "ping_log.txt");
+ } else {
+ strncpy(filename, dbv.pszVal, wParam);
+ DBFreeVariant(&dbv);
+ }
+
+ ((char *)lParam)[wParam - 1] = 0;
+
+ return 0;
+}
+
+INT_PTR SetLogFilename(WPARAM wParam, LPARAM lParam) {
+ DBWriteContactSettingString(0, PLUG, "LogFilename", (char *)lParam);
+ return 0;
+}
+
+INT_PTR ViewLogData(WPARAM wParam, LPARAM lParam) {
+ char buf[1024];
+ CallService(PLUG "/GetLogFilename", (WPARAM)MAX_PATH, (LPARAM)buf);
+ return (INT_PTR)ShellExecute((HWND)wParam, _T("edit"), buf, _T(""), _T(""), SW_SHOW);
+}
+
diff --git a/plugins/Ping/src/log.h b/plugins/Ping/src/log.h new file mode 100644 index 0000000000..8fed816122 --- /dev/null +++ b/plugins/Ping/src/log.h @@ -0,0 +1,12 @@ +#ifndef _PING_LOG
+#define _PING_LOG
+
+#pragma warning( disable : 4786 )
+#include "options.h"
+
+INT_PTR Log(WPARAM wParam, LPARAM lParam);
+INT_PTR GetLogFilename(WPARAM wParam, LPARAM lParam);
+INT_PTR SetLogFilename(WPARAM wParam, LPARAM lParam);
+INT_PTR ViewLogData(WPARAM wParam, LPARAM lParam);
+
+#endif
diff --git a/plugins/Ping/src/menu.cpp b/plugins/Ping/src/menu.cpp new file mode 100644 index 0000000000..dbec0a3447 --- /dev/null +++ b/plugins/Ping/src/menu.cpp @@ -0,0 +1,98 @@ +#include "common.h"
+#include "menu.h"
+
+HANDLE hMenuDisable, hMenuGraph, hMenuEdit;
+HANDLE hEventMenuBuild;
+
+/*
+int MenuBuild(WPARAM wParam, LPARAM lParam) {
+ CLISTMENUITEM menu;
+ ZeroMemory(&menu,sizeof(menu));
+ menu.cbSize=sizeof(menu);
+
+ menu.flags = CMIM_NAME | CMIM_ICON;
+ bool disable = DBGetContactSettingWord((HANDLE)wParam, PLUG, "Status", ID_STATUS_OFFLINE) != options.off_status;
+ if(disable) {
+ menu.hIcon = hIconDisabled;
+ menu.pszName = Translate("Disable");
+ } else {
+ menu.hIcon = hIconEnabled;
+ menu.pszName = Translate("Enable");
+ }
+ CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hMenuDisable, (LPARAM)&menu);
+
+ // hide graph menu item if window displayed
+ //menu.flags = CMIM_FLAGS | (DBGetContactSettingDword((HANDLE)wParam, PLUG, "WindowHandle", 0) == 0 ? 0 : CMIF_HIDDEN);
+ //CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hMenuGraph, (LPARAM)&menu);
+
+ return 0;
+}
+*/
+
+void InitMenus() {
+
+ CLISTMENUITEM menu;
+ ZeroMemory(&menu,sizeof(menu));
+ menu.cbSize=sizeof(menu);
+
+ // main menu
+ menu.flags = CMIF_TCHAR;
+ menu.popupPosition = 500099900;
+ menu.ptszPopupName = LPGENT("PING");
+ menu.cbSize = sizeof( menu );
+ menu.position = 2000060000;
+ menu.hIcon = hIconResponding;
+ menu.ptszName = LPGENT("Enable All Pings");
+ menu.pszService = PLUG "/EnableAll";
+ Menu_AddMainMenuItem(&menu);
+
+ menu.popupPosition = 500299901;
+ menu.cbSize = sizeof( menu );
+ menu.position = 2000060001;
+ menu.popupPosition = 0;
+ menu.hIcon = hIconDisabled;
+ menu.ptszName = LPGENT("Disable All Pings");
+ menu.pszService = PLUG "/DisableAll";
+ Menu_AddMainMenuItem(&menu);
+
+ /*
+ // list items
+ menu.flags = 0;
+ menu.popupPosition = 0;
+ menu.pszPopupName = 0;
+ menu.cbSize = sizeof( menu );
+ menu.position =-300100;
+ //menu.popupPosition = 0;
+ menu.hIcon = hIconDisabled;
+ menu.pszName = Translate( "Disable" );
+ menu.pszService = PLUG "/ToggleEnabled";
+ menu.pszContactOwner = PLUG;
+ hMenuDisable = (HANDLE)CallService( MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM)&menu );
+
+ menu.flags = 0;
+ menu.popupPosition = 0;
+ menu.pszPopupName = 0;
+ menu.cbSize = sizeof( menu );
+ menu.position =-300090;
+ //menu.popupPosition = 0;
+ menu.hIcon = hIconResponding
+ menu.pszName = Translate( "Graph" );
+ menu.pszService = PLUG "/ShowGraph";
+ menu.pszContactOwner = PLUG;
+ hMenuGraph = (HANDLE)CallService( MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM)&menu );
+
+ menu.flags = 0;
+ menu.popupPosition = 0;
+ menu.pszPopupName = 0;
+ menu.cbSize = sizeof( menu );
+ menu.position =-300080;
+ //menu.popupPosition = 0;
+ menu.hIcon = hIconResponding;
+ menu.pszName = Translate( "Edit..." );
+ menu.pszService = PLUG "/Edit";
+ menu.pszContactOwner = PLUG;
+ hMenuGraph = (HANDLE)CallService( MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM)&menu );
+
+ hEventMenuBuild = HookEvent(ME_CLIST_PREBUILDCONTACTMENU, MenuBuild);
+ */
+}
diff --git a/plugins/Ping/src/menu.h b/plugins/Ping/src/menu.h new file mode 100644 index 0000000000..e6e1334885 --- /dev/null +++ b/plugins/Ping/src/menu.h @@ -0,0 +1,10 @@ +#ifndef _MENU_H
+#define _MENU_H
+
+#include "pinglist.h"
+#include "pinggraph.h"
+#include "utils.h"
+
+void InitMenus();
+
+#endif
diff --git a/plugins/Ping/src/options.cpp b/plugins/Ping/src/options.cpp new file mode 100644 index 0000000000..1d19a67ded --- /dev/null +++ b/plugins/Ping/src/options.cpp @@ -0,0 +1,604 @@ +#include "common.h"
+#include "options.h"
+
+PingOptions options;
+
+// main ping options
+static INT_PTR CALLBACK DlgProcOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ HWND hw;
+ OPENFILENAME ofn = {0};
+
+ switch ( msg ) {
+ case WM_INITDIALOG: {
+ TranslateDialogDefault( hwndDlg );
+
+ if(ServiceExists(MS_CLIST_FRAMES_ADDFRAME)) {
+ hw = GetDlgItem(hwndDlg, IDC_CHK_ATTACH);
+ EnableWindow(hw, FALSE);
+ }
+ CheckDlgButton(hwndDlg, IDC_CHK_ATTACH, options.attach_to_clist);
+
+ SetDlgItemInt(hwndDlg, IDC_PPM, options.ping_period, FALSE);
+ SetDlgItemInt(hwndDlg, IDC_PT, options.ping_timeout, FALSE);
+ CheckDlgButton(hwndDlg, IDC_CHECKPOPUP, options.show_popup);
+ CheckDlgButton(hwndDlg, IDC_CHECKPOPUP2, options.show_popup2);
+ CheckDlgButton(hwndDlg, IDC_CHK_BLOCK, options.block_reps);
+ CheckDlgButton(hwndDlg, IDC_CHK_LOG, options.logging);
+ CheckDlgButton(hwndDlg, IDC_CHK_LOGCSV, options.log_csv);
+ CheckDlgButton(hwndDlg, IDC_CHK_NOTESTICON, options.no_test_icon);
+
+ SendMessage(GetDlgItem(hwndDlg, IDC_SP_INDENT), UDM_SETRANGE, 0, (LPARAM)MAKELONG(500, 0));
+ SendMessage(GetDlgItem(hwndDlg, IDC_SP_INDENT), UDM_SETPOS, 0, options.indent);
+ SendMessage(GetDlgItem(hwndDlg, IDC_SP_ROWHEIGHT), UDM_SETRANGE, 0, (LPARAM)MAKELONG(500, 6));
+ SendMessage(GetDlgItem(hwndDlg, IDC_SP_ROWHEIGHT), UDM_SETPOS, 0, options.row_height);
+
+ SetDlgItemInt(hwndDlg, IDC_RPT, options.retries, FALSE);
+
+ SetDlgItemText(hwndDlg, IDC_ED_FILENAME, options.log_filename);
+ if(!options.logging) {
+ hw = GetDlgItem(hwndDlg, IDC_ED_FILENAME);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_LOGBROWSE);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_CHK_LOGCSV);
+ EnableWindow(hw, FALSE);
+ }
+
+ if(!ServiceExists( MS_POPUP_ADDPOPUP )) {
+ hw = GetDlgItem(hwndDlg, IDC_CHECKPOPUP);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_CHECKPOPUP2);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_CHK_BLOCK);
+ EnableWindow(hw, FALSE);
+ }
+ return TRUE;
+ }
+ case WM_COMMAND:
+ if ( HIWORD( wParam ) == EN_CHANGE && ( HWND )lParam == GetFocus()) {
+ switch( LOWORD( wParam )) {
+ case IDC_PPM:
+ case IDC_PT:
+ case IDC_ED_FILENAME:
+ case IDC_RPT:
+ SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+ }
+ break;
+ }
+
+ if (HIWORD( wParam ) == CBN_SELCHANGE) {
+ SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+ break;
+ }
+
+ if ( HIWORD( wParam ) == BN_CLICKED ) {
+ switch( LOWORD( wParam )) {
+ case IDC_CHK_LOG:
+ hw = GetDlgItem(hwndDlg, IDC_ED_FILENAME);
+ EnableWindow(hw, IsDlgButtonChecked(hwndDlg, IDC_CHK_LOG));
+ hw = GetDlgItem(hwndDlg, IDC_BTN_LOGBROWSE);
+ EnableWindow(hw, IsDlgButtonChecked(hwndDlg, IDC_CHK_LOG));
+ hw = GetDlgItem(hwndDlg, IDC_CHK_LOGCSV);
+ EnableWindow(hw, IsDlgButtonChecked(hwndDlg, IDC_CHK_LOG));
+ // drop through
+ case IDC_CHK_LOGCSV:
+ case IDC_CHECKPOPUP:
+ case IDC_CHECKPOPUP2:
+ case IDC_CHK_BLOCK:
+ case IDC_CHK_MINMAX:
+ case IDC_CHK_NOTESTICON:
+ case IDC_CHK_ATTACH:
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ break;
+ case IDC_BTN_VIEWLOG:
+ CallService(PLUG "/ViewLogData", 0, 0);
+ break;
+ case IDC_BTN_LOGBROWSE:
+ ofn.lStructSize = sizeof(ofn);
+ ofn.lpstrFile = options.log_filename;
+ ofn.hwndOwner = hwndDlg;
+ ofn.Flags = CC_FULLOPEN;
+ //ofn.lpstrFile[0] = '\0';
+ ofn.nMaxFile = sizeof(options.log_filename);
+ ofn.lpstrFilter = _T("All\0*.*\0Text\0*.TXT\0");
+ ofn.nFilterIndex = 1;
+ ofn.lpstrFileTitle = NULL;
+ ofn.nMaxFileTitle = 0;
+ ofn.lpstrInitialDir = NULL;
+ ofn.Flags = OFN_PATHMUSTEXIST;
+
+ if(GetOpenFileName(&ofn) == TRUE) {
+ SetDlgItemText(hwndDlg, IDC_ED_FILENAME, ofn.lpstrFile);
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+ break;
+ }
+ break;
+ }
+ break;
+
+ case WM_NOTIFY:
+ if (((LPNMHDR)lParam)->code == UDN_DELTAPOS ) {
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+ if (((LPNMHDR)lParam)->code == PSN_APPLY ) {
+
+ BOOL trans_success;
+
+ DWORD new_ping_period = GetDlgItemInt( hwndDlg, IDC_PPM, &trans_success, FALSE);
+ if(trans_success) {
+ options.ping_period = new_ping_period;
+ }
+ DWORD new_ping_timeout = GetDlgItemInt( hwndDlg, IDC_PT, &trans_success, FALSE);
+ if(trans_success) {
+ options.ping_timeout = new_ping_timeout;
+ }
+ options.show_popup = IsDlgButtonChecked(hwndDlg, IDC_CHECKPOPUP) == BST_CHECKED;
+ options.show_popup2 = IsDlgButtonChecked(hwndDlg, IDC_CHECKPOPUP2) == BST_CHECKED;
+ options.block_reps = IsDlgButtonChecked(hwndDlg, IDC_CHK_BLOCK) == BST_CHECKED;
+ options.logging = IsDlgButtonChecked(hwndDlg, IDC_CHK_LOG) == BST_CHECKED;
+ options.log_csv = IsDlgButtonChecked(hwndDlg, IDC_CHK_LOGCSV) == BST_CHECKED;
+ GetDlgItemText(hwndDlg, IDC_ED_FILENAME, options.log_filename, MAX_PATH);
+
+ options.no_test_icon = IsDlgButtonChecked(hwndDlg, IDC_CHK_NOTESTICON) == BST_CHECKED;
+
+ options.indent = SendMessage(GetDlgItem(hwndDlg, IDC_SP_INDENT), UDM_GETPOS, 0, 0);
+ options.row_height = SendMessage(GetDlgItem(hwndDlg, IDC_SP_ROWHEIGHT), UDM_GETPOS, 0, 0);
+
+ DWORD new_retries = GetDlgItemInt( hwndDlg, IDC_RPT, &trans_success, FALSE);
+ if(trans_success) {
+ options.retries = new_retries;
+ }
+
+ bool new_attach = (IsDlgButtonChecked(hwndDlg, IDC_CHK_ATTACH) == BST_CHECKED);
+ if(!ServiceExists(MS_CLIST_FRAMES_ADDFRAME) && options.attach_to_clist != new_attach)
+ AttachToClist(new_attach);
+
+ options.attach_to_clist = new_attach;
+
+ SaveOptions();
+
+ RefreshWindow(0, 0);
+
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"options changed", 0);
+ if(hWakeEvent) SetEvent(hWakeEvent);
+ return TRUE;
+ }
+ break;
+ }
+
+ return FALSE;
+}
+
+PINGLIST temp_list;
+PINGADDRESS add_edit_addr;
+
+// host edit
+INT_PTR CALLBACK DlgProcDestEdit(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) {
+ HWND hw;
+ int sel;
+ char *strptr;
+
+ switch ( msg ) {
+ case WM_INITDIALOG:
+ {
+ for(int i = ID_STATUS_OFFLINE; i <= ID_STATUS_OUTTOLUNCH; i++) {
+ strptr = (char *)CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, (WPARAM)i, (LPARAM)0);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT);
+ SendMessage(hw, CB_INSERTSTRING, (WPARAM)-1, (LPARAM)strptr);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT2);
+ SendMessage(hw, CB_INSERTSTRING, (WPARAM)-1, (LPARAM)strptr);
+ }
+
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT);
+ SendMessage(hw, CB_SETCURSEL, 1, 0);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT2);
+ SendMessage(hw, CB_SETCURSEL, 0, 0);
+
+ SetDlgItemText(hwndDlg, IDC_ED_DESTADDR, add_edit_addr.pszName);
+ SetDlgItemText(hwndDlg, IDC_ED_DESTLAB, add_edit_addr.pszLabel);
+ SetDlgItemText(hwndDlg, IDC_ED_COMMAND, add_edit_addr.pszCommand);
+ SetDlgItemText(hwndDlg, IDC_ED_PARAMS, add_edit_addr.pszParams);
+
+ CheckDlgButton(hwndDlg, IDC_CHK_DESTTCP, add_edit_addr.port != -1);
+ if(add_edit_addr.port != -1) {
+ hw = GetDlgItem(hwndDlg, IDC_ED_DESTPORT);
+ EnableWindow(hw, TRUE);
+ SetDlgItemInt(hwndDlg, IDC_ED_DESTPORT, add_edit_addr.port, FALSE);
+ }
+ {
+ int num_protocols;
+ PROTOACCOUNT **pppDesc;
+
+ ProtoEnumAccounts(&num_protocols,&pppDesc);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTPROTO);
+ SendMessage(hw, CB_INSERTSTRING, (WPARAM)-1, (LPARAM)Translate("<none>"));
+ SendMessage(hw, CB_INSERTSTRING, (WPARAM)-1, (LPARAM)Translate("<all>"));
+ for(int i = 0; i < num_protocols; i++) {
+ SendMessage(hw, CB_INSERTSTRING, (WPARAM)-1, (LPARAM)pppDesc[i]->tszAccountName);
+ }
+
+ if(add_edit_addr.pszProto[0] == '\0') {
+ SendMessage(hw, CB_SETCURSEL, 0, 0);
+ } else {
+ SendMessage(hw, CB_SELECTSTRING, 0, (LPARAM)add_edit_addr.pszProto);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT);
+ EnableWindow(hw, TRUE);
+ SendMessage(hw, CB_SETCURSEL, (WPARAM)(add_edit_addr.set_status - ID_STATUS_OFFLINE), 0);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT2);
+ EnableWindow(hw, TRUE);
+ SendMessage(hw, CB_SETCURSEL, (WPARAM)(add_edit_addr.get_status - ID_STATUS_OFFLINE), 0);
+ }
+ }
+ // ? doesn't work? ?
+ hw = GetDlgItem(hwndDlg, IDC_ED_DESTLAB);
+ SetFocus(hw);
+ }
+ return FALSE;
+ case WM_COMMAND:
+ if (HIWORD( wParam ) == LBN_SELCHANGE && LOWORD(wParam) == IDC_COMBO_DESTPROTO) {
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTPROTO);
+ sel = SendMessage(hw, CB_GETCURSEL, 0, 0);
+ if(sel != CB_ERR) {
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT);
+ EnableWindow(hw, sel != 0);
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT2);
+ EnableWindow(hw, sel != 0);
+ }
+ }
+
+ if ( HIWORD( wParam ) == BN_CLICKED ) {
+ switch( LOWORD( wParam )) {
+ case IDC_CHK_DESTTCP:
+ hw = GetDlgItem(hwndDlg, IDC_ED_DESTPORT);
+ EnableWindow(hw, IsDlgButtonChecked(hwndDlg, IDC_CHK_DESTTCP));
+ break;
+ case IDOK:
+ GetDlgItemText(hwndDlg, IDC_ED_DESTADDR, add_edit_addr.pszName, MAX_PINGADDRESS_STRING_LENGTH);
+ GetDlgItemText(hwndDlg, IDC_ED_DESTLAB, add_edit_addr.pszLabel, MAX_PINGADDRESS_STRING_LENGTH);
+ GetDlgItemText(hwndDlg, IDC_ED_COMMAND, add_edit_addr.pszCommand, MAX_PATH);
+ GetDlgItemText(hwndDlg, IDC_ED_PARAMS, add_edit_addr.pszParams, MAX_PATH);
+
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTPROTO);
+ if(SendMessage(hw, CB_GETCURSEL, 0, 0) != -1) {
+ GetDlgItemText(hwndDlg, IDC_COMBO_DESTPROTO, add_edit_addr.pszProto, MAX_PINGADDRESS_STRING_LENGTH);
+ if(!strcmp(add_edit_addr.pszProto, Translate("<none>"))) add_edit_addr.pszProto[0] = '\0';
+ else {
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT);
+ sel = SendMessage(hw, CB_GETCURSEL, 0, 0);
+ if(sel != -1)
+ add_edit_addr.set_status = ID_STATUS_OFFLINE + sel;
+ hw = GetDlgItem(hwndDlg, IDC_COMBO_DESTSTAT2);
+ sel = SendMessage(hw, CB_GETCURSEL, 0, 0);
+ if(sel != -1)
+ add_edit_addr.get_status = ID_STATUS_OFFLINE + sel;
+ }
+ } else
+ add_edit_addr.pszProto[0] = '\0';
+
+ if(IsDlgButtonChecked(hwndDlg, IDC_CHK_DESTTCP)) {
+ BOOL tr;
+ int port = GetDlgItemInt(hwndDlg, IDC_ED_DESTPORT, &tr, FALSE);
+ if(tr) add_edit_addr.port = port;
+ else add_edit_addr.port = -1;
+ } else
+ add_edit_addr.port = -1;
+
+ EndDialog(hwndDlg, IDOK);
+ break;
+ case IDCANCEL:
+ EndDialog(hwndDlg, IDCANCEL);
+ break;
+ }
+
+ }
+
+ return TRUE;
+ }
+ return FALSE;
+}
+
+BOOL Edit(HWND hwnd, PINGADDRESS &addr) {
+ add_edit_addr = addr;
+ if(DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG3), hwnd, DlgProcDestEdit) == IDOK) {
+ addr = add_edit_addr;
+ return TRUE;
+ }
+ return FALSE;
+}
+// ping hosts list window
+static INT_PTR CALLBACK DlgProcOpts2(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ //OPENFILENAME ofn = {0};
+ HWND hw;
+ int sel;
+
+ switch ( msg ) {
+ case WM_INITDIALOG:
+ {
+ TranslateDialogDefault( hwndDlg );
+
+ Lock(&data_list_cs, "init options dialog");
+ temp_list = data_list;
+ Unlock(&data_list_cs);
+
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ for(PINGLIST::Iterator i = temp_list.start(); i.has_val(); i.next()) {
+ int index = SendMessage(hw, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)i.val().pszLabel);
+ SendMessage(hw, LB_SETITEMDATA, index, (LPARAM)&i.val());
+ }
+
+ }
+ return TRUE;
+
+ case WM_COMMAND:
+ if (HIWORD( wParam ) == LBN_SELCHANGE && LOWORD(wParam) == IDC_LST_DEST) {
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ sel = SendMessage(hw, LB_GETCURSEL, 0, 0);
+ if(sel != LB_ERR) {
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTREM);
+ EnableWindow(hw, TRUE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTEDIT);
+ EnableWindow(hw, TRUE);
+
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTUP);
+ EnableWindow(hw, (sel > 0));
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int count = SendMessage(hw, LB_GETCOUNT, 0, 0);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTDOWN);
+ EnableWindow(hw, (sel < count - 1));
+ }
+ }
+
+ if ( HIWORD( wParam ) == BN_CLICKED ) {
+ switch( LOWORD( wParam )) {
+ case IDC_BTN_DESTEDIT:
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ sel = SendMessage(hw, LB_GETCURSEL, 0, 0);
+ if(sel != LB_ERR) {
+ PINGADDRESS *item = (PINGADDRESS *)SendMessage(hw, LB_GETITEMDATA, sel, 0);
+ PINGADDRESS temp = *item;
+ if(Edit(hwndDlg, temp)) {
+ *item = temp;
+ SendMessage(hw, LB_DELETESTRING, (WPARAM)sel, (LPARAM)0);
+ SendMessage(hw, LB_INSERTSTRING, (WPARAM)sel, (LPARAM)item->pszLabel);
+ SendMessage(hw, LB_SETITEMDATA, (WPARAM)sel, (LPARAM)item);
+ SendMessage(hw, LB_SETCURSEL, (WPARAM)sel, 0);
+
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTREM);
+ EnableWindow(hw, TRUE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTEDIT);
+ EnableWindow(hw, TRUE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTUP);
+ EnableWindow(hw, sel > 0);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTDOWN);
+ int count = SendMessage(hw, LB_GETCOUNT, 0, 0);
+ EnableWindow(hw, (sel < count - 1));
+
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+ }
+ break;
+ case IDC_BTN_DESTADD:
+
+ memset(&add_edit_addr,0,sizeof(add_edit_addr));
+ add_edit_addr.cbSize = sizeof(add_edit_addr);
+ add_edit_addr.port = -1;
+ add_edit_addr.set_status = ID_STATUS_ONLINE;
+ add_edit_addr.get_status = ID_STATUS_OFFLINE;
+ add_edit_addr.status = PS_NOTRESPONDING;
+ add_edit_addr.item_id = 0;
+
+ if(DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG3), hwndDlg, DlgProcDestEdit) == IDOK) {
+
+ temp_list.add(add_edit_addr);
+
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int index = SendMessage(hw, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)add_edit_addr.pszLabel);
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ SendMessage(hw, LB_SETCURSEL, (WPARAM)index, 0);
+
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTREM);
+ EnableWindow(hw, TRUE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTEDIT);
+ EnableWindow(hw, TRUE);
+
+ sel = temp_list.size() - 1;
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTUP);
+ EnableWindow(hw, (sel > 0));
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int count = SendMessage(hw, LB_GETCOUNT, 0, 0);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTDOWN);
+ EnableWindow(hw, (sel < count - 1));
+
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+
+ break;
+ case IDC_BTN_DESTREM:
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ sel = SendMessage(hw, LB_GETCURSEL, 0, 0);
+ if(sel != LB_ERR) {
+ PINGADDRESS *item = (PINGADDRESS *)SendMessage(hw, LB_GETITEMDATA, sel, 0);
+ SendMessage(hw, LB_DELETESTRING, (WPARAM)sel, 0);
+ temp_list.remove(*item);
+ }
+
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTREM);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTEDIT);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTUP);
+ EnableWindow(hw, FALSE);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTDOWN);
+ EnableWindow(hw, FALSE);
+
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ break;
+ case IDC_BTN_DESTDOWN:
+ {
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int sel2 = SendMessage(hw, LB_GETCURSEL, 0, 0);
+ if(sel2 != LB_ERR) {
+ PINGADDRESS *item = (PINGADDRESS *)SendMessage(hw, LB_GETITEMDATA, sel2, 0),
+ *item2 = (PINGADDRESS *)SendMessage(hw, LB_GETITEMDATA, sel2 + 1, 0);
+ add_edit_addr = *item;
+ *item = *item2;
+ *item2 = add_edit_addr;
+
+ // keep indexes the same, as they're used for sorting the binary tree
+ int index = item->index, index2 = item2->index;
+ item->index = index2;
+ item2->index = index;
+
+ SendMessage(hw, LB_DELETESTRING, (WPARAM)sel2, (LPARAM)0);
+ SendMessage(hw, LB_INSERTSTRING, (WPARAM)sel2, (LPARAM)item->pszLabel);
+ SendMessage(hw, LB_SETITEMDATA, (WPARAM)sel2, (LPARAM)item);
+ SendMessage(hw, LB_DELETESTRING, (WPARAM)(sel2 + 1), (LPARAM)0);
+ SendMessage(hw, LB_INSERTSTRING, (WPARAM)(sel2 + 1), (LPARAM)item2->pszLabel);
+ SendMessage(hw, LB_SETITEMDATA, (WPARAM)(sel2 + 1), (LPARAM)item2);
+ SendMessage(hw, LB_SETCURSEL, (WPARAM)(sel2 + 1), 0);
+
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTUP);
+ EnableWindow(hw, (sel2 + 1 > 0));
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int count = SendMessage(hw, LB_GETCOUNT, 0, 0);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTDOWN);
+ EnableWindow(hw, (sel2 + 1 < count - 1));
+
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+ }
+ break;
+ case IDC_BTN_DESTUP:
+ {
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int sel2 = SendMessage(hw, LB_GETCURSEL, 0, 0);
+ if(sel2 != LB_ERR) {
+ PINGADDRESS *item = (PINGADDRESS *)SendMessage(hw, LB_GETITEMDATA, sel2, 0),
+ *item2 = (PINGADDRESS *)SendMessage(hw, LB_GETITEMDATA, sel2 - 1, 0);
+ add_edit_addr = *item;
+ *item = *item2;
+ *item2 = add_edit_addr;
+
+ // keep indexes the same, as they're used for sorting the binary tree
+ int index = item->index, index2 = item2->index;
+ item->index = index2;
+ item2->index = index;
+
+ SendMessage(hw, LB_DELETESTRING, (WPARAM)sel2, (LPARAM)0);
+ SendMessage(hw, LB_INSERTSTRING, (WPARAM)sel2, (LPARAM)item->pszLabel);
+ SendMessage(hw, LB_SETITEMDATA, (WPARAM)sel2, (LPARAM)item);
+
+ SendMessage(hw, LB_DELETESTRING, (WPARAM)(sel2 - 1), (LPARAM)0);
+ SendMessage(hw, LB_INSERTSTRING, (WPARAM)(sel2 - 1), (LPARAM)item2->pszLabel);
+ SendMessage(hw, LB_SETITEMDATA, (WPARAM)(sel2 - 1), (LPARAM)item2);
+
+ SendMessage(hw, LB_SETCURSEL, (WPARAM)(sel2 - 1), 0);
+
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTUP);
+ EnableWindow(hw, (sel2 - 1 > 0));
+ hw = GetDlgItem(hwndDlg, IDC_LST_DEST);
+ int count = SendMessage(hw, LB_GETCOUNT, 0, 0);
+ hw = GetDlgItem(hwndDlg, IDC_BTN_DESTDOWN);
+ EnableWindow(hw, (sel2 - 1 < count - 1));
+
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+ }
+
+ break;
+ }
+ }
+ if(LOWORD(wParam) == IDC_BGCOL
+ || LOWORD(wParam) == IDC_SP_INDENT || LOWORD(wParam) == IDC_SP_ROWHEIGHT)
+ {
+ SendMessage( GetParent( hwndDlg ), PSM_CHANGED, 0, 0 );
+ }
+ break;
+
+ case WM_NOTIFY:
+ if (((LPNMHDR)lParam)->code == PSN_APPLY ) {
+ CallService(PLUG "/SetAndSavePingList", (WPARAM)&temp_list, 0);
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&temp_list);
+ // the following will be affected due to list rebuild event
+ //if(hWakeEvent) SetEvent(hWakeEvent);
+ return TRUE;
+ }
+ break;
+
+ }
+ return FALSE;
+}
+
+int PingOptInit(WPARAM wParam,LPARAM lParam)
+{
+ OPTIONSDIALOGPAGE odp = { 0 };
+ odp.cbSize = sizeof(odp);
+ odp.hInstance = hInst;
+ odp.flags = ODPF_BOLDGROUPS|ODPF_TCHAR;
+ odp.ptszGroup = LPGENT("Network");
+ odp.ptszTitle = LPGENT("PING");
+
+ odp.ptszTab = LPGENT("Settings");
+ odp.pszTemplate = MAKEINTRESOURCE(IDD_DIALOG1);
+ odp.pfnDlgProc = DlgProcOpts;
+ Options_AddPage(wParam,&odp);
+
+ odp.ptszTab = LPGENT("Hosts");
+ odp.pszTemplate = MAKEINTRESOURCE(IDD_DIALOG2);
+ odp.pfnDlgProc = DlgProcOpts2;
+ Options_AddPage(wParam,&odp);
+
+ return 0;
+}
+
+void LoadOptions() {
+ options.ping_period = DBGetContactSettingDword(NULL, PLUG, "PingPeriod", DEFAULT_PING_PERIOD);
+
+ options.ping_timeout = DBGetContactSettingDword(NULL, PLUG, "PingTimeout", DEFAULT_PING_TIMEOUT);
+ CallService(PLUG "/SetPingTimeout", (WPARAM)options.ping_timeout, 0);
+ options.show_popup = (DBGetContactSettingByte(NULL, PLUG, "ShowPopup", DEFAULT_SHOW_POPUP ? 1 : 0) == 1);
+ options.show_popup2 = (DBGetContactSettingByte(NULL, PLUG, "ShowPopup2", DEFAULT_SHOW_POPUP2 ? 1 : 0) == 1);
+ options.block_reps = (DBGetContactSettingByte(NULL, PLUG, "BlockReps", DEFAULT_BLOCK_REPS ? 1 : 0) == 1);
+ options.logging = (DBGetContactSettingByte(NULL, PLUG, "LoggingEnabled", DEFAULT_LOGGING_ENABLED ? 1 : 0) == 1);
+
+ options.no_test_icon = (DBGetContactSettingByte(NULL, PLUG, "NoTestStatus", DEFAULT_NO_TEST_ICON ? 1 : 0) == 1);
+
+ options.indent = DBGetContactSettingWord(NULL, PLUG, "Indent", 0);
+ options.row_height = DBGetContactSettingWord(NULL, PLUG, "RowHeight", GetSystemMetrics(SM_CYSMICON));
+
+ options.retries = DBGetContactSettingDword(NULL, PLUG, "Retries", 0);
+
+ CallService(PLUG "/GetLogFilename", (WPARAM)MAX_PATH, (LPARAM)options.log_filename);
+
+ ICMP::get_instance()->set_timeout(options.ping_timeout * 1000);
+
+ options.attach_to_clist = (DBGetContactSettingByte(NULL, PLUG, "AttachToClist", DEFAULT_ATTACH_TO_CLIST ? 1 : 0) == 1);
+ options.log_csv = (DBGetContactSettingByte(NULL, PLUG, "LogCSV", 0) == 1);
+}
+
+void SaveOptions() {
+ DBWriteContactSettingDword(NULL, PLUG, "PingPeriod", options.ping_period);
+ DBWriteContactSettingDword(NULL, PLUG, "PingTimeout", options.ping_timeout);
+ CallService(PLUG "/SetPingTimeout", (WPARAM)options.ping_timeout, 0);
+ DBWriteContactSettingByte(NULL, PLUG, "ShowPopup", options.show_popup ? 1 : 0);
+ DBWriteContactSettingByte(NULL, PLUG, "ShowPopup2", options.show_popup2 ? 1 : 0);
+ DBWriteContactSettingByte(NULL, PLUG, "BlockReps", options.block_reps ? 1 : 0);
+ DBWriteContactSettingByte(NULL, PLUG, "LoggingEnabled", options.logging ? 1 : 0);
+
+ DBWriteContactSettingByte(NULL, PLUG, "NoTestStatus", options.no_test_icon ? 1 : 0);
+
+ DBWriteContactSettingWord(NULL, PLUG, "Indent", options.indent);
+ DBWriteContactSettingWord(NULL, PLUG, "RowHeight", options.row_height);
+
+ DBWriteContactSettingDword(NULL, PLUG, "Retries", (DWORD)options.retries);
+
+ CallService(PLUG "/SetLogFilename", (WPARAM)MAX_PATH, (LPARAM)options.log_filename);
+
+ ICMP::get_instance()->set_timeout(options.ping_timeout * 1000);
+
+ DBWriteContactSettingByte(NULL, PLUG, "AttachToClist", options.attach_to_clist ? 1 : 0);
+ DBWriteContactSettingByte(NULL, PLUG, "LogCSV", options.log_csv ? 1 : 0);
+}
diff --git a/plugins/Ping/src/options.h b/plugins/Ping/src/options.h new file mode 100644 index 0000000000..1963649bfb --- /dev/null +++ b/plugins/Ping/src/options.h @@ -0,0 +1,26 @@ +#ifndef _PING_OPTIONS
+#define _PING_OPTIONS
+
+#include "pinglist.h"
+#include "utils.h"
+#include "icmp.h"
+#include "pingthread.h"
+
+#include "resource.h"
+
+// wake event for ping thread
+extern HANDLE hWakeEvent;
+
+extern PingOptions options;
+extern PINGADDRESS add_edit_addr;
+
+INT_PTR CALLBACK DlgProcDestEdit(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
+
+int PingOptInit(WPARAM wParam,LPARAM lParam);
+
+BOOL Edit(HWND hwnd, PINGADDRESS &addr);
+
+void LoadOptions();
+void SaveOptions();
+
+#endif
diff --git a/plugins/Ping/src/ping.cpp b/plugins/Ping/src/ping.cpp new file mode 100644 index 0000000000..10803ce5c5 --- /dev/null +++ b/plugins/Ping/src/ping.cpp @@ -0,0 +1,179 @@ +#include "common.h"
+#include "ping.h"
+#include <list>
+HINSTANCE hInst;
+int hLangpack = 0;
+
+HANDLE hNetlibUser = 0;
+HANDLE hFillListEvent = 0;
+
+bool use_raw_ping = true;
+
+// plugin stuff
+PLUGININFOEX pluginInfo={
+ sizeof(PLUGININFOEX),
+ "Ping Plugin",
+ PLUGIN_MAKE_VERSION(0, 9, 1, 1),
+ "Ping labelled IP addresses or domain names.",
+ "Scott Ellis",
+ "mail@scottellis.com.au",
+ "© 2005 Scott Ellis",
+ "http://www.scottellis.com.au/",
+ UNICODE_AWARE, //not transient
+ { 0x760ea901, 0xc0c2, 0x446c, { 0x80, 0x29, 0x94, 0xc3, 0xbc, 0x47, 0xc4, 0x5e } } // {760EA901-C0C2-446c-8029-94C3BC47C45E}
+};
+
+extern "C" BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved)
+{
+ hInst=hinstDLL;
+ DisableThreadLibraryCalls(hInst);
+ return TRUE;
+}
+
+extern "C" PING_API PLUGININFOEX* MirandaPluginInfoEx(DWORD mirandaVersion)
+{
+ return &pluginInfo;
+}
+
+static const MUUID interfaces[] = {MIID_PING, MIID_LAST};
+extern "C" __declspec(dllexport) const MUUID* MirandaPluginInterfaces(void)
+{
+ return interfaces;
+}
+
+
+
+void CreatePluginServices() {
+ // general
+ CreateServiceFunction(PLUG "/Ping", PluginPing);
+ CreateServiceFunction(PLUG "/DblClick", DblClick);
+
+ // list
+ CreateServiceFunction(PLUG "/ClearPingList", ClearPingList);
+ CreateServiceFunction(PLUG "/GetPingList", GetPingList);
+ CreateServiceFunction(PLUG "/SetPingList", SetPingList);
+ CreateServiceFunction(PLUG "/SetAndSavePingList", SetAndSavePingList);
+ CreateServiceFunction(PLUG "/LoadPingList", LoadPingList);
+ CreateServiceFunction(PLUG "/SavePingList", SavePingList);
+
+ reload_event_handle = CreateHookableEvent(PLUG "/ListReload");
+
+ //log
+ CreateServiceFunction(PLUG "/Log", Log);
+ CreateServiceFunction(PLUG "/ViewLogData", ViewLogData);
+ CreateServiceFunction(PLUG "/GetLogFilename", GetLogFilename);
+ CreateServiceFunction(PLUG "/SetLogFilename", SetLogFilename);
+
+ // menu
+ CreateServiceFunction(PLUG "/DisableAll", PingDisableAll);
+ CreateServiceFunction(PLUG "/EnableAll", PingEnableAll);
+ CreateServiceFunction(PLUG "/ToggleEnabled", ToggleEnabled);
+ CreateServiceFunction(PLUG "/ShowGraph", ShowGraph);
+ CreateServiceFunction(PLUG "/Edit", EditContact);
+
+}
+
+int OnShutdown(WPARAM wParam, LPARAM lParam) {
+ graphs_cleanup();
+
+ UnhookEvent(hFillListEvent);
+
+ if(use_raw_ping)
+ cleanup_raw_ping();
+ else
+ ICMP::cleanup();
+
+ DeinitList();
+
+ return 0;
+}
+
+int OnModulesLoaded(WPARAM wParam, LPARAM lParam) {
+ NETLIBUSER nl_user = {0};
+ nl_user.cbSize = sizeof(nl_user);
+ nl_user.szSettingsModule = PLUG;
+ //nl_user.flags = NUF_OUTGOING | NUF_HTTPGATEWAY | NUF_NOOPTIONS;
+ //nl_user.flags = NUF_OUTGOING | NUF_NOOPTIONS;
+ nl_user.flags = NUF_OUTGOING | NUF_HTTPCONNS | NUF_TCHAR;
+ nl_user.ptszDescriptiveName = LPGENT("Ping Plugin");
+ nl_user.szHttpGatewayHello = 0;
+ nl_user.szHttpGatewayUserAgent = 0;
+ nl_user.pfnHttpGatewayInit = 0;
+ nl_user.pfnHttpGatewayWrapSend = 0;
+ nl_user.pfnHttpGatewayUnwrapRecv = 0;
+
+ hNetlibUser = (HANDLE)CallService(MS_NETLIB_REGISTERUSER, 0, (LPARAM)&nl_user);
+
+ InitUtils();
+
+ InitMenus();
+
+ hFillListEvent = HookEvent(PLUG "/ListReload", FillList);
+
+ if(!DBGetContactSettingByte(0, PLUG, "PingPlugImport", 0)) {
+ if(DBGetContactSettingDword(0, "PingPlug", "NumEntries", 0)) {
+ import_ping_addresses();
+ DBWriteContactSettingByte(0, PLUG, "PingPlugImport", 1);
+ }
+ }
+
+ InitList();
+
+ CallService(PLUG "/LoadPingList", 0, 0);
+
+ graphs_init();
+
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"start", 0);
+
+ return 0;
+}
+
+extern "C" PING_API int Load(void)
+{
+ //if(init_raw_ping()) {
+ //MessageBox(0, Translate("Failed to initialize. Plugin disabled."), Translate("Ping Plugin"), MB_OK | MB_ICONERROR);
+ //return 1;
+ use_raw_ping = false;
+ //}
+ DBWriteContactSettingByte(0, PLUG, "UsingRawSockets", (BYTE)use_raw_ping);
+
+ DuplicateHandle( GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &mainThread, THREAD_SET_CONTEXT, FALSE, 0 );
+ hWakeEvent = CreateEvent(NULL, FALSE, FALSE, _T("Local\\ThreadWaitEvent"));
+
+ InitializeCriticalSection(&list_cs);
+ InitializeCriticalSection(&thread_finished_cs);
+ InitializeCriticalSection(&list_changed_cs);
+ InitializeCriticalSection(&data_list_cs);
+
+ // create services before loading options - so we can have the 'getlogfilename' service!
+ CreatePluginServices();
+
+ LoadOptions();
+
+ SkinAddNewSound("PingTimeout", "Ping Timout", 0);
+ SkinAddNewSound("PingReply", "Ping Reply", 0);
+
+ HookEvent(ME_SYSTEM_MODULESLOADED, OnModulesLoaded);
+
+ HookEvent(ME_OPT_INITIALISE, PingOptInit );
+
+ HookEvent(ME_SYSTEM_PRESHUTDOWN, OnShutdown);
+
+ return 0;
+}
+
+extern "C" PING_API int Unload(void)
+{
+ SavePingList(0, 0);
+
+ DeleteCriticalSection(&list_cs);
+ DeleteCriticalSection(&thread_finished_cs);
+ DeleteCriticalSection(&list_changed_cs);
+ DeleteCriticalSection(&data_list_cs);
+
+ CloseHandle( mainThread );
+
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"stop", 0);
+
+ return 0;
+}
diff --git a/plugins/Ping/src/ping.h b/plugins/Ping/src/ping.h new file mode 100644 index 0000000000..8a1b1730bd --- /dev/null +++ b/plugins/Ping/src/ping.h @@ -0,0 +1,41 @@ +/*
+Based on the
+Miranda plugin template, originally by Richard Hughes
+http://miranda-icq.sourceforge.net/
+
+© 2004 Scott Ellis
+
+*/
+
+#ifndef _PING
+#define _PING
+
+
+// The following ifdef block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the PINGPROTO_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// PINGPROTO_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+#ifdef PING_EXPORTS
+#define PING_API __declspec(dllexport)
+#else
+#define PING_API __declspec(dllimport)
+#endif
+
+#include "utils.h"
+#include "options.h"
+#include "pinglist.h"
+#include "log.h"
+#include "pingthread.h"
+#include "menu.h"
+#include "rawping.h"
+
+// globals
+extern PLUGININFOEX pluginInfo;
+
+extern "C" PING_API PLUGININFOEX* MirandaPluginInfoEx(DWORD mirandaVersion);
+extern "C" PING_API int Load(void);
+extern "C" PING_API int Unload(void);
+
+#endif
diff --git a/plugins/Ping/src/pinggraph.cpp b/plugins/Ping/src/pinggraph.cpp new file mode 100644 index 0000000000..30d5d6c2df --- /dev/null +++ b/plugins/Ping/src/pinggraph.cpp @@ -0,0 +1,325 @@ +#include "common.h"
+#include "pinggraph.h"
+
+HistoryMap history_map;
+
+#define ID_REPAINT_TIMER 10101
+
+struct WindowData {
+ DWORD item_id;
+ HistoryList list;
+ HWND hwnd_chk_grid;
+ HWND hwnd_chk_stat;
+ bool show_grid;
+ bool show_stat;
+};
+
+#define WM_REBUILDLIST (WM_USER + 5)
+
+LRESULT CALLBACK GraphWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ switch(msg) {
+ case WM_REBUILDLIST:
+ {
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+
+ bool found = false;
+ EnterCriticalSection(&data_list_cs);
+ for(PINGLIST::Iterator i = data_list.start(); i.has_val(); i.next()) {
+ if(i.val().item_id == wd->item_id) {
+ wd->list = history_map[wd->item_id];
+ found = true;
+ break;
+ }
+ }
+ LeaveCriticalSection(&data_list_cs);
+
+ if(!found) {
+ PostMessage(hwnd, WM_CLOSE, 0, 0);
+ return TRUE;
+ }
+
+ InvalidateRect(hwnd, 0, FALSE);
+ }
+ return TRUE;
+ case WM_SHOWWINDOW:
+ if(wParam == TRUE && lParam == 0) {
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+
+ if(wd->hwnd_chk_grid == 0) {
+ wd->hwnd_chk_grid = CreateWindow(_T("BUTTON"), TranslateT("Show grid lines"), WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 0, 0, 0, 0, hwnd, 0, hInst, 0);
+ SendMessage(wd->hwnd_chk_grid, BM_SETCHECK, wd->show_grid ? BST_CHECKED : BST_UNCHECKED, 0);
+ }
+ if(wd->hwnd_chk_stat == 0) {
+ wd->hwnd_chk_stat = CreateWindow(_T("BUTTON"), TranslateT("Show stats"), WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 0, 0, 0, 0, hwnd, 0, hInst, 0);
+ SendMessage(wd->hwnd_chk_stat, BM_SETCHECK, wd->show_stat ? BST_CHECKED : BST_UNCHECKED, 0);
+ }
+ KillTimer(hwnd, ID_REPAINT_TIMER);
+#ifdef min
+ SetTimer(hwnd, ID_REPAINT_TIMER, min(options.ping_period * 1000, 5000), 0);
+#else
+ SetTimer(hwnd, ID_REPAINT_TIMER, std::min(options.ping_period * 1000, 5000), 0);
+#endif
+
+ SendMessage(hwnd, WM_REBUILDLIST, 0, 0);
+ }
+ break;
+ case WM_COMMAND:
+ if(HIWORD(wParam) == BN_CLICKED) {
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+ if((HWND)lParam == wd->hwnd_chk_grid) {
+ wd->show_grid = (SendMessage(wd->hwnd_chk_grid, BM_GETCHECK, 0, 0) == BST_CHECKED);
+ } else if((HWND)lParam == wd->hwnd_chk_stat) {
+ wd->show_stat = (SendMessage(wd->hwnd_chk_stat, BM_GETCHECK, 0, 0) == BST_CHECKED);
+ }
+ InvalidateRect(hwnd, 0, TRUE);
+ }
+ return TRUE;
+ case WM_TIMER:
+ {
+ SendMessage(hwnd, WM_REBUILDLIST, 0, 0);
+ }
+ return TRUE;
+ case WM_PAINT:
+ {
+ PAINTSTRUCT ps;
+ HDC hdc;
+ RECT r;
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+ if(wd && (hdc = BeginPaint(hwnd, &ps)) != 0) {
+ GetClientRect(hwnd, &r);
+ FillRect(hdc, &r, GetSysColorBrush(COLOR_WINDOW));
+
+ short max_value = -1, min_value = (short)0x7FFF,
+ graph_height = 0; // this is minimum graph height, in ms
+ double avg = 0;
+ for(HistoryList::Iterator hli = wd->list.start(); hli.has_val(); hli.next()) {
+ if(hli.val().first > max_value) max_value = hli.val().first;
+ if(hli.val().first >= 0 && hli.val().first < min_value) min_value = hli.val().first;
+ avg += hli.val().first;
+ }
+ if(wd->list.size())
+ avg /= wd->list.size();
+
+ graph_height = (int)(max_value * 1.2f);
+ if(graph_height < MIN_GRAPH_HEIGHT) graph_height = MIN_GRAPH_HEIGHT;
+
+#ifdef max
+ float unit_width = (r.right - r.left) / (float)max((int)wd->list.size(), MIN_BARS), // space for at least MIN_BARS bars
+#else
+ float unit_width = (r.right - r.left) / (float)std::max((int)wd->list.size(), MIN_BARS), // space for at least MIN_BARS bars
+#endif
+ unit_height = (r.bottom - r.top) / (float)graph_height;
+
+ time_t last_time = 0, time, start_time = 0;
+ if(wd->list.size())
+ start_time = wd->list.start().val().second;
+
+ RECT bar;
+ bar.bottom = r.bottom;
+ float x = r.right - (unit_width * wd->list.size() + 0.5f);
+ bar.left = (int)(x + 0.5f);
+ bar.right = (int)(x + unit_width + 0.5f);
+
+ // set up pen for horiz (ping time) and vert (time covered by graph) lines
+ HPEN hPenOld, hPen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW));
+ hPenOld = (HPEN)SelectObject(hdc, hPen);
+
+ for(HistoryList::Iterator hi = wd->list.start(); hi.has_val(); hi.next()) {
+ if(hi.val().first != -1) {
+ bar.top = bar.bottom - (int)(hi.val().first * unit_height + 0.5f);
+ FillRect(hdc, &bar, GetSysColorBrush(COLOR_HOTLIGHT));
+ }
+
+ time = hi.val().second - start_time;
+
+ if(time / MARK_PERIOD != last_time / MARK_PERIOD) { // new minute
+ MoveToEx(hdc, bar.left, r.bottom, 0);
+ LineTo(hdc, bar.left, r.top);
+ }
+
+ last_time = time;
+
+ x += unit_width;
+ bar.left = bar.right;
+ bar.right = (int)(x + unit_width + 0.5f);
+ }
+
+ if(wd->show_grid) {
+ // draw horizontal lines to mark every 100ms
+ for(int li = 0; li < graph_height; li += MARK_TIME) {
+ MoveToEx(hdc, r.left, r.bottom - (int)(li * unit_height + 0.5f), 0);
+ LineTo(hdc, r.right, r.bottom - (int)(li * unit_height + 0.5f));
+ }
+ }
+
+ HPEN hPen2 = CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
+ if(wd->show_stat) {
+ SelectObject(hdc, hPen2);
+ MoveToEx(hdc, r.left, r.bottom - (int)(avg * unit_height + 0.5f), 0);
+ LineTo(hdc, r.right, r.bottom - (int)(avg * unit_height + 0.5f));
+ if(max_value != avg) {
+ MoveToEx(hdc, r.left, r.bottom - (int)(max_value * unit_height + 0.5f), 0);
+ LineTo(hdc, r.right, r.bottom - (int)(max_value * unit_height + 0.5f));
+ MoveToEx(hdc, r.left, r.bottom - (int)(min_value * unit_height + 0.5f), 0);
+ LineTo(hdc, r.right, r.bottom - (int)(min_value * unit_height + 0.5f));
+ }
+ }
+
+ // restore pen
+ SelectObject(hdc, hPenOld);
+ DeleteObject(hPen);
+ DeleteObject(hPen2);
+
+ SetBkMode(hdc, TRANSPARENT);
+ SetTextColor(hdc, GetSysColor(COLOR_3DDKSHADOW));
+ char buff[64];
+ if(wd->show_grid) {
+ sprintf(buff, Translate("%d ms"), MARK_TIME);
+ TextOut(hdc, r.right - 100, r.bottom - (int)(unit_height * MARK_TIME + 0.5f), buff, strlen(buff));
+ }
+
+ if(wd->show_stat) {
+ SetTextColor(hdc, RGB(255, 0, 0));
+ sprintf(buff, Translate("AVG %.1lf ms"), avg);
+ TextOut(hdc, r.left + 10, r.bottom - (int)(avg * unit_height + 0.5f), buff, strlen(buff));
+ if(max_value != avg) {
+ sprintf(buff, Translate("MAX %hd ms"), max_value);
+ TextOut(hdc, r.left + 10, r.bottom - (int)(max_value * unit_height + 0.5f), buff, strlen(buff));
+ sprintf(buff, Translate("MIN %hd ms"), min_value);
+ TextOut(hdc, r.left + 10, r.bottom - (int)(min_value * unit_height + 0.5f), buff, strlen(buff));
+ }
+ }
+
+ EndPaint(hwnd, &ps);
+ }
+ }
+ return TRUE;
+
+ case WM_ERASEBKGND:
+ return TRUE;
+
+ case WM_SIZE:
+ {
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+ RECT r;
+ GetClientRect(hwnd, &r);
+ if(wd->hwnd_chk_grid != 0) SetWindowPos(wd->hwnd_chk_grid, 0, r.right - 150, r.top + 10, 120, 20, SWP_NOZORDER | SWP_NOACTIVATE);
+ if(wd->hwnd_chk_stat != 0) SetWindowPos(wd->hwnd_chk_stat, 0, r.right - 150, r.top + 30, 120, 20, SWP_NOZORDER | SWP_NOACTIVATE);
+ }
+ InvalidateRect(hwnd, 0, FALSE);
+ break;
+ case WM_CLOSE:
+ {
+ KillTimer(hwnd, ID_REPAINT_TIMER);
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+ {
+ char buff[30];
+ sprintf(buff, "pinggraphwnd%d", wd->item_id);
+ Utils_SaveWindowPosition(hwnd, 0, PLUG, buff);
+ }
+ }
+ break;
+ case WM_DESTROY:
+ {
+ WindowData *wd = (WindowData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+ {
+ char buff[30];
+ sprintf(buff, "WindowHandle%d", wd->item_id);
+ DBWriteContactSettingDword(0, PLUG, buff, 0);
+ }
+ delete wd;
+ }
+ // drop through
+ };
+
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+INT_PTR ShowGraph(WPARAM wParam, LPARAM lParam) {
+ char buff[30];
+ sprintf(buff, "WindowHandle%d", (DWORD)wParam);
+ HWND hGraphWnd = (HWND)DBGetContactSettingDword(0, PLUG, buff, 0);
+ if(hGraphWnd) {
+ ShowWindow(hGraphWnd, SW_SHOW);
+ SetWindowPos(hGraphWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ return 0;
+ }
+
+ WNDCLASS wndclass;
+ wndclass.style = 0;
+ wndclass.lpfnWndProc = GraphWindowProc;
+ wndclass.cbClsExtra = 0;
+ wndclass.cbWndExtra = 0;
+ wndclass.hInstance = hInst;
+ wndclass.hIcon = hIconResponding;
+ wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
+ wndclass.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
+ wndclass.lpszMenuName = NULL;
+ wndclass.lpszClassName = _T(PLUG) _T("GraphWindow");
+ RegisterClass(&wndclass);
+
+ char title[256];
+ strcpy(title, "Ping Graph");
+ if(lParam) {
+ strcat(title, " - ");
+ strncat(title, (char *)lParam, 256 - 13);
+ }
+
+ HWND parent = 0;
+ hGraphWnd = CreateWindowEx(0, _T(PLUG) _T("GraphWindow"), title,
+ (WS_THICKFRAME | WS_CAPTION | WS_SYSMENU | WS_CLIPCHILDREN) & ~CS_VREDRAW & ~CS_HREDRAW,
+ 0,0,800,600,parent,NULL,hInst,NULL);
+
+ WindowData *wd = new WindowData;
+ wd->item_id = (DWORD)wParam; // wParam is destination id
+ wd->hwnd_chk_grid = 0;
+ wd->hwnd_chk_stat = 0;
+ wd->show_grid = DBGetContactSettingByte(0, PLUG, "ShowGridLines", 0) ? true : false;
+ wd->show_stat = DBGetContactSettingByte(0, PLUG, "ShowStats", 1) ? true : false;
+
+ DBWriteContactSettingDword(0, PLUG, buff, (DWORD)hGraphWnd);
+
+ SetWindowLongPtr(hGraphWnd, GWLP_USERDATA, (LONG_PTR)wd);
+
+ sprintf(buff, "pinggraphwnd%d", wd->item_id);
+ Utils_RestoreWindowPosition(hGraphWnd, 0, PLUG, buff);
+
+ if(!IsWindowVisible(hGraphWnd))
+ ShowWindow(hGraphWnd, SW_SHOW);
+
+ return 0;
+}
+
+// save window positions, close windows
+void graphs_cleanup() {
+ int list_size = GetListSize(0, 0);
+ char buff[64];
+ HWND hwnd;
+
+ for(int i = 0; i < list_size; i++) {
+ sprintf(buff, "WindowHandle%d", i);
+ if(hwnd = (HWND)DBGetContactSettingDword(0, PLUG, buff, 0)) {
+ DestroyWindow(hwnd);
+ DBWriteContactSettingDword(0, PLUG, buff, 0);
+ sprintf(buff, "WindowWasOpen%d", i);
+ DBWriteContactSettingByte(0, PLUG, buff, 1);
+ }
+ }
+}
+
+// remove old data, possibly left from a crash
+void graphs_init() {
+ PINGLIST pl;
+ char buff[64];
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+ for(PINGLIST::Iterator i = pl.start(); i.has_val(); i.next()) {
+ sprintf(buff, "WindowHandle%d", i.val().item_id); // clean up from possible crash
+ DBWriteContactSettingDword(0, PLUG, buff, 0);
+ sprintf(buff, "WindowWasOpen%d", i.val().item_id); // restore windows that were open on shutdown
+ if(DBGetContactSettingByte(0, PLUG, buff, 0)) {
+ DBWriteContactSettingByte(0, PLUG, buff, 0);
+ ShowGraph((WPARAM)i.val().item_id, (LPARAM)i.val().pszLabel);
+ }
+ }
+}
diff --git a/plugins/Ping/src/pinggraph.h b/plugins/Ping/src/pinggraph.h new file mode 100644 index 0000000000..268b376a58 --- /dev/null +++ b/plugins/Ping/src/pinggraph.h @@ -0,0 +1,22 @@ +#ifndef _PINGGRAPH_H
+#define _PINGGRAPH_H
+
+#include "pinglist.h"
+#include "pingthread.h"
+
+#define MIN_GRAPH_HEIGHT 10 // minimum braph height, ms
+#define MIN_BARS 20 // space for at least this many bars
+#define MARK_PERIOD 3600 // vertical lines every this many secs (3600 == 1 hour)
+#define MARK_TIME 100 // horizontal lines every this many ms
+
+INT_PTR ShowGraph(WPARAM wParam, LPARAM lParam);
+
+// save window positions, close windows
+void graphs_cleanup();
+
+// restore windows that were open when cleanup was called last?
+void graphs_init();
+
+extern HistoryMap history_map;
+
+#endif
diff --git a/plugins/Ping/src/pinglist.cpp b/plugins/Ping/src/pinglist.cpp new file mode 100644 index 0000000000..91d00f97af --- /dev/null +++ b/plugins/Ping/src/pinglist.cpp @@ -0,0 +1,230 @@ +#include "common.h"
+#include "pinglist.h"
+
+#include "options.h"
+
+PINGLIST list_items;
+CRITICAL_SECTION list_cs;
+HANDLE reload_event_handle;
+
+DWORD NextID = 1;
+
+BOOL clist_handle_changing = FALSE;
+
+BOOL changing_clist_handle() {
+ return clist_handle_changing;
+}
+
+void set_changing_clist_handle(BOOL flag) {
+ clist_handle_changing = flag;
+}
+
+const bool PINGADDRESS::operator==(const PINGADDRESS &b) const {
+ return index == b.index;
+}
+
+const bool PINGADDRESS::operator<(const PINGADDRESS &b) const {
+ return index < b.index;
+}
+
+// lParam is address of pointer to a std::list<PINGADDRESS>
+// copies data into this structure
+INT_PTR GetPingList(WPARAM wParam,LPARAM lParam)
+{
+ PINGLIST *pa = (PINGLIST *)lParam;
+
+ EnterCriticalSection(&list_cs);
+ *pa = list_items;
+ LeaveCriticalSection(&list_cs);
+
+ return 0;
+}
+
+INT_PTR GetListSize(WPARAM wParam, LPARAM lParam) {
+ INT_PTR ret = 0;
+ EnterCriticalSection(&list_cs);
+ ret = list_items.size();
+ LeaveCriticalSection(&list_cs);
+ return ret;
+}
+
+void write_ping_address(PINGADDRESS *i) {
+ char buff[16];
+ sprintf(buff, "PING_DEST_%d", i->index);
+
+ if(i->item_id == 0) {
+ i->item_id = NextID++;
+ DBWriteContactSettingDword(0, PLUG, "NextID", NextID);
+ }
+
+ DBWriteContactSettingDword(0, buff, "Id", i->item_id);
+ DBWriteContactSettingString(0, buff, "Address", i->pszName);
+ DBWriteContactSettingString(0, buff, "Label", i->pszLabel);
+ DBWriteContactSettingWord(0, buff, "Status", i->status);
+ DBWriteContactSettingDword(0, buff, "Port", i->port);
+ DBWriteContactSettingString(0, buff, "Proto", i->pszProto);
+ if(strlen(i->pszCommand))
+ DBWriteContactSettingString(0, buff, "Command", i->pszCommand);
+ else
+ DBDeleteContactSetting(0, buff, "Command");
+ if(strlen(i->pszParams))
+ DBWriteContactSettingString(0, buff, "CommandParams", i->pszParams);
+ else
+ DBDeleteContactSetting(0, buff, "CommandParams");
+ DBWriteContactSettingWord(0, buff, "SetStatus", i->set_status);
+ DBWriteContactSettingWord(0, buff, "GetStatus", i->get_status);
+ DBWriteContactSettingWord(0, buff, "Index", i->index);
+}
+
+// call with list_cs locked
+void write_ping_addresses() {
+ int index = 0;
+ for(PINGLIST::Iterator i = list_items.start(); i.has_val(); i.next(), index++) {
+ i.val().index = index;
+ write_ping_address(&i.val());
+ }
+
+ // mark further destinations in the DB as invalid
+ char buff[16];
+ bool found;
+
+ do {
+ found = false;
+ sprintf(buff, "PING_DEST_%d", index++);
+ if(DBGetContactSettingDword(0, buff, "Id", 0) != 0) {
+ found = true;
+ DBWriteContactSettingDword(0, buff, "Id", 0);
+ }
+ } while(found);
+}
+
+bool read_ping_address(PINGADDRESS &pa) {
+ int index = pa.index;
+
+ char buff[16];
+ sprintf(buff, "PING_DEST_%d", index);
+
+ // return if not more contacts, or only deleted contacts remaining
+ if((pa.item_id = DBGetContactSettingDword(0, buff, "Id", 0)) == 0) return false;
+
+ DBVARIANT dbv;
+ if(!DBGetContactSetting(0, buff, "Address", &dbv)) {
+ strncpy(pa.pszName, dbv.pszVal, MAX_PINGADDRESS_STRING_LENGTH);
+ DBFreeVariant(&dbv);
+ } else return false;
+
+ if(!DBGetContactSetting(0, buff, "Label", &dbv)) {
+ strncpy(pa.pszLabel, dbv.pszVal, MAX_PINGADDRESS_STRING_LENGTH);
+ DBFreeVariant(&dbv);
+ } else return false;
+
+ pa.status = DBGetContactSettingWord(0, buff, "Status", PS_NOTRESPONDING);
+ if(pa.status != PS_DISABLED) pa.status = PS_NOTRESPONDING;
+
+ pa.port = (int)DBGetContactSettingDword(0, buff, "Port", -1);
+
+ if(!DBGetContactSetting(0, buff, "Proto", &dbv)) {
+ strncpy(pa.pszProto, dbv.pszVal, MAX_PINGADDRESS_STRING_LENGTH);
+ DBFreeVariant(&dbv);
+ } else pa.pszProto[0] = '\0';
+
+ if(!DBGetContactSetting(0, buff, "Command", &dbv)) {
+ strncpy(pa.pszCommand, dbv.pszVal, MAX_PATH);
+ DBFreeVariant(&dbv);
+ } else
+ pa.pszCommand[0] = '\0';
+ if(!DBGetContactSetting(0, buff, "CommandParams", &dbv)) {
+ strncpy(pa.pszParams, dbv.pszVal, MAX_PATH);
+ DBFreeVariant(&dbv);
+ } else
+ pa.pszParams[0] = '\0';
+
+ pa.set_status = DBGetContactSettingWord(0, buff, "SetStatus", ID_STATUS_ONLINE);
+ pa.get_status = DBGetContactSettingWord(0, buff, "GetStatus", ID_STATUS_OFFLINE);
+
+ pa.responding = false;
+ pa.round_trip_time = 0;
+ pa.miss_count = 0;
+ pa.index = DBGetContactSettingWord(0, buff, "Index", 0);
+
+ pa.index = index;
+ if(pa.item_id >= NextID) {
+ NextID = pa.item_id + 1;
+ DBWriteContactSettingDword(0, PLUG, "NextID", NextID);
+ }
+
+ return true;
+}
+
+// call with list_cs locked
+void read_ping_addresses() {
+ PINGADDRESS pa;
+
+ pa.index = 0;
+
+
+ list_items.clear();
+ while(read_ping_address(pa)) {
+ list_items.add(pa);
+ pa.index++;
+ }
+}
+
+INT_PTR LoadPingList(WPARAM wParam, LPARAM lParam) {
+ EnterCriticalSection(&list_cs);
+ read_ping_addresses();
+ LeaveCriticalSection(&list_cs);
+ NotifyEventHooks(reload_event_handle, 0, 0);
+ return 0;
+}
+
+// wParam is zero
+// lParam is zero
+INT_PTR SavePingList(WPARAM wParam, LPARAM lParam) {
+ EnterCriticalSection(&list_cs);
+ write_ping_addresses();
+ LeaveCriticalSection(&list_cs);
+ //NotifyEventHooks(reload_event_handle, 0, 0);
+
+ return 0;
+}
+
+// wParam is address of a PINGLIST structure to replace the current one
+// lParam is zero
+INT_PTR SetPingList(WPARAM wParam, LPARAM lParam) {
+ PINGLIST *pli = (PINGLIST *)wParam;
+
+ EnterCriticalSection(&list_cs);
+ list_items = *pli;
+ LeaveCriticalSection(&list_cs);
+ NotifyEventHooks(reload_event_handle, 0, 0);
+
+ return 0;
+}
+
+// wParam is address of a PINGLIST structure to replace the current one
+// lParam is zero
+INT_PTR SetAndSavePingList(WPARAM wParam, LPARAM lParam) {
+ PINGLIST *pli = (PINGLIST *)wParam;
+
+ EnterCriticalSection(&list_cs);
+
+ // set new list
+ list_items = *pli;
+ write_ping_addresses();
+ LeaveCriticalSection(&list_cs);
+
+ NotifyEventHooks(reload_event_handle, 0, 0);
+
+ return 0;
+}
+
+INT_PTR ClearPingList(WPARAM wParam, LPARAM lParam) {
+ EnterCriticalSection(&list_cs);
+ list_items.clear();
+ LeaveCriticalSection(&list_cs);
+
+ NotifyEventHooks(reload_event_handle, 0, 0);
+ return 0;
+}
+
diff --git a/plugins/Ping/src/pinglist.h b/plugins/Ping/src/pinglist.h new file mode 100644 index 0000000000..ed2a94810f --- /dev/null +++ b/plugins/Ping/src/pinglist.h @@ -0,0 +1,26 @@ +#ifndef _PINGLIST_H
+#define _PINGLIST_H
+
+typedef BinaryTree<PINGADDRESS> PINGLIST;
+
+#include <algorithm> // for sort
+
+extern PINGLIST list_items;
+extern HANDLE reload_event_handle;
+extern CRITICAL_SECTION list_cs;
+
+INT_PTR LoadPingList(WPARAM wParam, LPARAM lParam);
+INT_PTR GetPingList(WPARAM wParam,LPARAM lParam);
+INT_PTR SavePingList(WPARAM wParam, LPARAM lParam);
+INT_PTR SetPingList(WPARAM wParam, LPARAM lParam); // use when you modified db yourself
+INT_PTR SetAndSavePingList(WPARAM wParam, LPARAM lParam);
+INT_PTR ClearPingList(WPARAM wParam, LPARAM lParam);
+INT_PTR GetListSize(WPARAM wParam, LPARAM lParam);
+
+// only call with list_cs locked!
+void write_ping_addresses();
+
+
+BOOL changing_clist_handle();
+void set_changing_clist_handle(BOOL flag);
+#endif
diff --git a/plugins/Ping/src/pingthread.cpp b/plugins/Ping/src/pingthread.cpp new file mode 100644 index 0000000000..5db0f4322e --- /dev/null +++ b/plugins/Ping/src/pingthread.cpp @@ -0,0 +1,1063 @@ +#include "common.h"
+#include "pingthread.h"
+
+int upCount, total = 0;
+
+int list_size = 0;
+
+HANDLE mainThread;
+HANDLE hWakeEvent = 0;
+
+// thread protected variables
+CRITICAL_SECTION thread_finished_cs, list_changed_cs, data_list_cs;
+bool thread_finished = false, list_changed = false;
+PINGLIST data_list;
+
+HANDLE status_update_thread = 0;
+
+HWND hpwnd = 0, list_hwnd, hwnd_clist = 0;
+int frame_id = -1;
+
+HBRUSH tbrush = 0;
+
+FontID font_id;
+ColourID bk_col_id;
+HFONT hFont = 0;
+COLORREF bk_col = RGB(255, 255, 255);
+
+////////////////
+#define WinVerMajor() LOBYTE(LOWORD(GetVersion()))
+#define WinVerMinor() HIBYTE(LOWORD(GetVersion()))
+#define IsWinVer2000Plus() (WinVerMajor()>=5)
+
+static HMODULE hUserDll;
+BOOL (WINAPI *MySetLayeredWindowAttributes)(HWND,COLORREF,BYTE,DWORD);
+BOOL (WINAPI *MyAnimateWindow)(HWND hWnd,DWORD dwTime,DWORD dwFlags);
+#define TM_AUTOALPHA 1
+static int transparentFocus=1;
+/////////////////
+
+bool get_thread_finished() {
+ Lock(&thread_finished_cs, "get_thread_finished");
+ bool retval = thread_finished;
+ Unlock(&thread_finished_cs);
+ return retval;
+}
+
+void set_thread_finished(bool f) {
+ Lock(&thread_finished_cs, "set_thread_finished");
+ thread_finished = f;
+ Unlock(&thread_finished_cs);
+}
+
+bool get_list_changed() {
+ Lock(&list_changed_cs, "get_list_changed");
+ bool retval = list_changed;
+ Unlock(&list_changed_cs);
+ return retval;
+}
+
+void set_list_changed(bool f) {
+ Lock(&list_changed_cs, "set_list_changed");
+ list_changed = f;
+ Unlock(&list_changed_cs);
+}
+
+void SetProtoStatus(char *pszLabel, char *pszProto, int if_status, int new_status) {
+ if(strcmp(pszProto, Translate("<all>")) == 0) {
+ int num_protocols;
+ PROTOACCOUNT **pppDesc;
+
+ ProtoEnumAccounts(&num_protocols,&pppDesc);
+ for(int i = 0; i < num_protocols; i++) {
+ SetProtoStatus(pszLabel, pppDesc[i]->szModuleName, if_status, new_status);
+ }
+ } else {
+ char get_status[512], set_status[512];
+ mir_snprintf(get_status, 512, "%s%s", pszProto, PS_GETSTATUS);
+ if(ServiceExists(get_status)) {
+ mir_snprintf(set_status, 512, "%s%s", pszProto, PS_SETSTATUS);
+ if(CallService(get_status, 0, 0) == if_status) {
+ if(options.logging) {
+ char buf[1024];
+ mir_snprintf(buf, 1024, Translate("%s - setting status of protocol '%s' (%d)"), pszLabel, pszProto, new_status);
+ CallService(PLUG "/Log", (WPARAM)buf, 0);
+ }
+ CallService(set_status, new_status, 0);
+ }
+ }
+ }
+}
+
+DWORD WINAPI sttCheckStatusThreadProc( void *vp)
+{
+ clock_t start_t = clock(), end_t;
+ while(!get_thread_finished()) {
+
+ end_t = clock();
+
+ int wait = (int)((options.ping_period - ((end_t - start_t) / (double)CLOCKS_PER_SEC)) * 1000);
+ if(wait > 0)
+ WaitForSingleObjectEx(hWakeEvent, wait, TRUE);
+
+ if(get_thread_finished()) break;
+
+ start_t = clock();
+
+ bool timeout = false;
+ bool reply = false;
+ int count = 0;
+
+ PINGADDRESS pa;
+ HistPair history_entry;
+
+ Lock(&data_list_cs, "ping thread loop start");
+ set_list_changed(false);
+ int size = data_list.size();
+ Unlock(&data_list_cs);
+
+ int index = 0;
+ for(; index < size; index++) {
+ Lock(&data_list_cs, "ping thread loop start");
+ int c = 0;
+ for(PINGLIST::Iterator i = data_list.start(); i.has_val() && c <= index; i.next(), c++) {
+ if(c == index) {
+ // copy just what we need - i.e. not history, not command
+ pa.get_status = i.val().get_status;
+ pa.item_id = i.val().item_id;
+ pa.miss_count = i.val().miss_count;
+ pa.port = i.val().port;
+ strcpy(pa.pszLabel, i.val().pszLabel);
+ strcpy(pa.pszName, i.val().pszName);
+ strcpy(pa.pszProto, i.val().pszProto);
+ pa.set_status = i.val().set_status;
+ pa.status = i.val().status;
+ break;
+ }
+
+ }
+ Unlock(&data_list_cs);
+
+ if(get_thread_finished()) break;
+ if(get_list_changed()) break;
+
+ if(pa.status != PS_DISABLED) {
+ if(!options.no_test_icon) {
+ Lock(&data_list_cs, "ping thread loop start");
+ for(PINGLIST::Iterator i = data_list.start(); i.has_val(); i.next()) {
+ if(i.val().item_id == pa.item_id) {
+ i.val().status = PS_TESTING;
+ }
+ }
+ Unlock(&data_list_cs);
+ InvalidateRect(list_hwnd, 0, FALSE);
+ }
+
+ CallService(PLUG "/Ping", 0, (LPARAM)&pa);
+
+ if(get_thread_finished()) break;
+ if(get_list_changed()) break;
+
+ Lock(&data_list_cs, "ping thread loop start");
+ for(PINGLIST::Iterator i = data_list.start(); i.has_val(); i.next()) {
+ if(i.val().item_id == pa.item_id) {
+ i.val().responding = pa.responding;
+ i.val().round_trip_time = pa.round_trip_time;
+ history_entry.first = i.val().round_trip_time;
+ history_entry.second = time(0);
+ history_map[i.val().item_id].push_back(history_entry);
+ // maintain history (-1 represents no response)
+ while(history_map[i.val().item_id].size() >= MAX_HISTORY)
+ //history_map[i.val().item_id].pop_front();
+ history_map[i.val().item_id].remove(history_map[i.val().item_id].start().val());
+
+ if(pa.responding) {
+ if(pa.miss_count > 0)
+ pa.miss_count = -1;
+ else
+ pa.miss_count--;
+ pa.status = PS_RESPONDING;
+ }
+ else {
+ if(pa.miss_count < 0)
+ pa.miss_count = 1;
+ else
+ pa.miss_count++;
+ pa.status = PS_NOTRESPONDING;
+ }
+ i.val().miss_count = pa.miss_count;
+ i.val().status = pa.status;
+
+ break;
+ }
+ }
+ Unlock(&data_list_cs);
+
+ if(pa.responding) {
+ count++;
+
+ if(pa.miss_count == -1 - options.retries ||
+ (((-pa.miss_count) % (options.retries + 1)) == 0 && !options.block_reps))
+ {
+ reply = true;
+ if(options.show_popup2 && ServiceExists(MS_POPUP_SHOWMESSAGE)) {
+ ShowPopup("Ping Reply", pa.pszLabel, 1);
+ }
+ }
+ if(pa.miss_count == -1 - options.retries && options.logging) {
+ char buf[512];
+ mir_snprintf(buf, 512, Translate("%s - reply, %d"), pa.pszLabel, pa.round_trip_time);
+ CallService(PLUG "/Log", (WPARAM)buf, 0);
+ }
+ SetProtoStatus(pa.pszLabel, pa.pszProto, pa.get_status, pa.set_status);
+ } else {
+
+ if(pa.miss_count == 1 + options.retries ||
+ ((pa.miss_count % (options.retries + 1)) == 0 && !options.block_reps))
+ {
+ timeout = true;
+ if(options.show_popup && ServiceExists(MS_POPUP_SHOWMESSAGE)) {
+ ShowPopup("Ping Timeout", pa.pszLabel, 0);
+ }
+ }
+ if(pa.miss_count == 1 + options.retries && options.logging) {
+ char buf[512];
+ mir_snprintf(buf, 512, Translate("%s - timeout"), pa.pszLabel);
+ CallService(PLUG "/Log", (WPARAM)buf, 0);
+ }
+ }
+
+ InvalidateRect(list_hwnd, 0, FALSE);
+ }
+ }
+
+ if(timeout) SkinPlaySound("PingTimeout");
+ if(reply) SkinPlaySound("PingReply");
+
+ if(!get_list_changed()) {
+ upCount = count;
+ total = index;
+ } else {
+ total = 0;
+ }
+ }
+
+ return 0;
+}
+
+void start_ping_thread() {
+ DWORD tid;
+
+ if(status_update_thread) CloseHandle(status_update_thread);
+ status_update_thread = CreateThread(0, 0, sttCheckStatusThreadProc, 0, 0, &tid);
+}
+
+void stop_ping_thread() {
+ set_thread_finished(true);
+ SetEvent(hWakeEvent);
+ //ICMP::get_instance()->stop();
+ WaitForSingleObject(status_update_thread, 2000);
+ TerminateThread(status_update_thread, 0);
+ CloseHandle(status_update_thread);
+ status_update_thread = 0;
+}
+
+bool FrameIsFloating() {
+ if(frame_id == -1)
+ return true; // no frames, always floating
+
+ return (CallService(MS_CLIST_FRAMES_GETFRAMEOPTIONS, MAKEWPARAM(FO_FLOATING, frame_id), 0) != 0);
+}
+
+int FillList(WPARAM wParam, LPARAM lParam) {
+
+ if(options.logging)
+ CallService(PLUG "/Log", (WPARAM)"ping address list reload", 0);
+
+ PINGLIST pl;
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+
+ SendMessage(list_hwnd, WM_SETREDRAW, (WPARAM)FALSE, 0);
+ Lock(&data_list_cs, "fill_list");
+
+ data_list = pl;
+ SendMessage(list_hwnd, LB_RESETCONTENT, 0, 0);
+
+ int index = 0;
+ for(PINGLIST::Iterator j = data_list.start(); j.has_val(); j.next(), index++) {
+ SendMessage(list_hwnd, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)&j.val());
+ }
+ set_list_changed(true);
+
+ list_size = data_list.size();
+
+ Unlock(&data_list_cs);
+ SendMessage(list_hwnd, WM_SETREDRAW, (WPARAM)TRUE, 0);
+
+ InvalidateRect(list_hwnd, 0, FALSE);
+
+ SetEvent(hWakeEvent);
+
+ if(!ServiceExists(MS_CLIST_FRAMES_ADDFRAME) && options.attach_to_clist)
+ UpdateFrame();
+
+ return 0;
+}
+
+INT_PTR PingPlugShowWindow(WPARAM wParam, LPARAM lParam) {
+ if(hpwnd) {
+ if(frame_id != -1 && ServiceExists(MS_CLIST_FRAMES_SHFRAME)) CallService(MS_CLIST_FRAMES_SHFRAME, (WPARAM)frame_id, 0);
+ else {
+ ShowWindow(hpwnd, IsWindowVisible(hpwnd) ? SW_HIDE : SW_SHOW);
+ }
+ }
+ return 0;
+}
+
+#define TIMER_ID 11042
+void CALLBACK TimerProc(
+ HWND hwnd, // handle to window
+ UINT uMsg, // WM_TIMER message
+ UINT_PTR idEvent, // timer identifier
+ DWORD dwTime // current system time
+)
+{
+ if(frame_id != -1 && ServiceExists(MS_CLIST_FRAMES_ADDFRAME)) {
+ char TBcapt[255];
+ if(total > 0)
+ wsprintf(TBcapt,"Ping (%d/%d)", upCount, total);
+ else
+ wsprintf(TBcapt,"Ping");
+
+ CallService(MS_CLIST_FRAMES_SETFRAMEOPTIONS,MAKEWPARAM(FO_TBNAME,frame_id),(LPARAM)TBcapt);
+ CallService(MS_CLIST_FRAMES_SETFRAMEOPTIONS,MAKEWPARAM(FO_TBTIPNAME,frame_id),(LPARAM)TBcapt);
+ CallService(MS_CLIST_FRAMES_UPDATEFRAME,frame_id,FU_TBREDRAW);
+ } else {
+// if(options.attach_to_clist) {
+// AttachToClist(true);
+// }
+ }
+}
+
+DWORD context_point;
+bool context_point_valid = false;
+LRESULT CALLBACK FrameWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ RECT rect;
+ MEASUREITEMSTRUCT *mis;
+ LPDRAWITEMSTRUCT dis;
+ SIZE textSize;
+ PINGADDRESS itemData;
+ RECT r;
+ LPARAM lp;
+ int sel;
+
+ switch(msg)
+ {
+
+ case WM_MEASUREITEM:
+ mis = (MEASUREITEMSTRUCT *)lParam;
+ mis->itemWidth = 100;
+ mis->itemHeight = options.row_height;
+ return TRUE;
+
+ case WM_DRAWITEM:
+ dis = (LPDRAWITEMSTRUCT)lParam;
+ if(dis->hwndItem == list_hwnd) {
+ HBRUSH ttbrush = 0;
+ COLORREF tcol;
+ if(dis->itemID != -1) {
+ Lock(&data_list_cs, "draw item");
+ itemData = *(PINGADDRESS *)dis->itemData;
+ Unlock(&data_list_cs);
+
+ SendMessage(list_hwnd, LB_SETITEMHEIGHT, 0, (LPARAM)options.row_height);
+ //dis->rcItem.bottom = dis->rcItem.top + options.row_height;
+
+ LONG x, y;
+ if(context_point_valid) {
+ RECT r;
+ GetWindowRect(list_hwnd, &r);
+ x = LOWORD(context_point) - r.left,
+ y = HIWORD(context_point) - r.top;
+ }
+
+ GetClientRect(hwnd, &r);
+
+ if((dis->itemState & ODS_SELECTED && dis->itemState & ODS_FOCUS)
+ || (context_point_valid && (x >= dis->rcItem.left && x <= dis->rcItem.right) && (y >= dis->rcItem.top && y <= dis->rcItem.bottom)))
+ {
+ tcol = DBGetContactSettingDword(NULL,"CLC","SelBkColour", GetSysColor(COLOR_HIGHLIGHT));
+ SetBkColor(dis->hDC, tcol);
+ FillRect(dis->hDC, &dis->rcItem, (ttbrush = CreateSolidBrush(tcol)));
+
+ tcol = DBGetContactSettingDword(NULL,"CLC","SelTextColour", GetSysColor(COLOR_HIGHLIGHTTEXT));
+ SetTextColor(dis->hDC, tcol);
+ } else {
+ tcol = bk_col;
+ SetBkColor(dis->hDC, tcol);
+ FillRect(dis->hDC, &dis->rcItem, (ttbrush = CreateSolidBrush(tcol)));
+
+ tcol = DBGetContactSettingDword(NULL, PLUG, "FontCol", GetSysColor(COLOR_WINDOWTEXT));
+ SetTextColor(dis->hDC, tcol);
+ }
+
+ SetBkMode(dis->hDC, TRANSPARENT);
+ HICON hIcon = (itemData.status != PS_DISABLED ? (itemData.status == PS_TESTING ? hIconTesting : (itemData.status == PS_RESPONDING ? hIconResponding : hIconNotResponding)) : hIconDisabled);
+ dis->rcItem.left += options.indent;
+ //DrawIconEx(dis->hDC,dis->rcItem.left,(dis->rcItem.top + dis->rcItem.bottom - GetSystemMetrics(SM_CYSMICON))>>1,hIcon,GetSystemMetrics(SM_CXSMICON),GetSystemMetrics(SM_CYSMICON),0,NULL,DI_NORMAL);
+ //DrawIconEx(dis->hDC,dis->rcItem.left,(dis->rcItem.top + dis->rcItem.bottom - GetSystemMetrics(SM_CYSMICON))>>1,hIcon,0, 0, 0, NULL, DI_NORMAL);
+ DrawIconEx(dis->hDC,dis->rcItem.left,dis->rcItem.top + ((options.row_height - 16)>>1),hIcon,0, 0, 0, NULL, DI_NORMAL);
+
+ GetTextExtentPoint32(dis->hDC,itemData.pszLabel,lstrlen(itemData.pszLabel),&textSize);
+ TextOut(dis->hDC,dis->rcItem.left + 16 + 4,(dis->rcItem.top + dis->rcItem.bottom - textSize.cy)>>1,itemData.pszLabel,lstrlen(itemData.pszLabel));
+
+ if(itemData.status != PS_DISABLED) {
+ char buf[256];
+ if(itemData.responding) {
+ mir_snprintf(buf, 256, Translate("%d ms"), itemData.round_trip_time);
+ GetTextExtentPoint32(dis->hDC,buf,lstrlen(buf),&textSize);
+ TextOut(dis->hDC,dis->rcItem.right - textSize.cx - 2,(dis->rcItem.top + dis->rcItem.bottom -textSize.cy)>>1,buf,lstrlen(buf));
+ } else if(itemData.miss_count > 0) {
+ mir_snprintf(buf, 256, "[%d]", itemData.miss_count);
+ GetTextExtentPoint32(dis->hDC,buf,lstrlen(buf),&textSize);
+ TextOut(dis->hDC,dis->rcItem.right - textSize.cx - 2,(dis->rcItem.top + dis->rcItem.bottom -textSize.cy)>>1,buf,lstrlen(buf));
+ }
+ }
+ SetBkMode(dis->hDC, OPAQUE);
+ }
+ if(ttbrush) DeleteObject(ttbrush);
+ return TRUE;
+ }
+ //return DefWindowProc(hwnd, msg, wParam, lParam);
+ return TRUE;
+
+ case WM_CTLCOLORLISTBOX:
+ {
+ if(tbrush) DeleteObject(tbrush);
+
+ return (BOOL)(tbrush = CreateSolidBrush(bk_col));
+ }
+
+ case WM_ERASEBKGND:
+ {
+ RECT r;
+ GetClientRect(hwnd, &r);
+ if(!tbrush) tbrush = CreateSolidBrush(bk_col);
+ FillRect((HDC)wParam, &r, tbrush);
+ }
+ return TRUE;
+
+ case WM_CONTEXTMENU:
+ {
+ context_point = lParam;
+ context_point_valid = true;
+ InvalidateRect(list_hwnd, 0, FALSE);
+ HMENU menu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_MENU1)),
+ submenu = GetSubMenu(menu, 0);
+
+ POINT pt = {LOWORD(context_point),HIWORD(context_point)};
+
+ RECT r;
+ GetClientRect(list_hwnd, &r);
+ ScreenToClient(list_hwnd, &pt);
+
+ DWORD item = SendMessage(list_hwnd, LB_ITEMFROMPOINT, 0, MAKELPARAM(pt.x, pt.y));
+ bool found = false;
+ if(HIWORD(item) == 0) {
+ int count = LOWORD(item);
+ Lock(&data_list_cs, "show graph");
+ if(count >= 0 && count < (int)data_list.size()) {
+ itemData = *(PINGADDRESS *)SendMessage(list_hwnd, LB_GETITEMDATA, count, 0);
+ found = true;
+ }
+ Unlock(&data_list_cs);
+
+ }
+
+ if(found) {
+ EnableMenuItem(submenu, ID_MENU_GRAPH, MF_BYCOMMAND | MF_ENABLED);
+ EnableMenuItem(submenu, ID_MENU_EDIT, MF_BYCOMMAND | MF_ENABLED);
+ EnableMenuItem(submenu, ID_MENU_TOGGLE, MF_BYCOMMAND | MF_ENABLED);
+ if(itemData.status == PS_DISABLED) {
+ ModifyMenu(submenu, ID_MENU_TOGGLE, MF_BYCOMMAND | MF_STRING, ID_MENU_TOGGLE, TranslateT("Enable"));
+ } else {
+ ModifyMenu(submenu, ID_MENU_TOGGLE, MF_BYCOMMAND | MF_STRING, ID_MENU_TOGGLE, TranslateT("Disable"));
+ }
+ } else {
+ EnableMenuItem(submenu, ID_MENU_GRAPH, MF_BYCOMMAND | MF_GRAYED);
+ EnableMenuItem(submenu, ID_MENU_EDIT, MF_BYCOMMAND | MF_GRAYED);
+ EnableMenuItem(submenu, ID_MENU_TOGGLE, MF_BYCOMMAND | MF_GRAYED);
+ }
+
+ CallService(MS_LANGPACK_TRANSLATEMENU,(WPARAM)submenu,0);
+
+ //ClientToScreen(list_hwnd, &pt);
+ GetCursorPos(&pt);
+ BOOL ret = TrackPopupMenu(submenu, TPM_TOPALIGN|TPM_LEFTALIGN|TPM_RIGHTBUTTON|TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
+ DestroyMenu(menu);
+ if(ret) {
+ SendMessage(hwnd, WM_COMMAND, ret, 0);
+ }
+ context_point_valid = false;
+ InvalidateRect(list_hwnd, 0, FALSE);
+ }
+
+ return TRUE;
+
+ case WM_SYSCOLORCHANGE:
+ SendMessage(list_hwnd,msg,wParam,lParam);
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+
+ case WM_CREATE:
+ list_hwnd = CreateWindow("LISTBOX", "",
+ //(WS_VISIBLE | WS_CHILD | LBS_NOINTEGRALHEIGHT| LBS_STANDARD | WS_CLIPCHILDREN | LBS_OWNERDRAWVARIABLE | LBS_NOTIFY)
+ (WS_VISIBLE | WS_CHILD | LBS_STANDARD | LBS_OWNERDRAWFIXED | LBS_NOTIFY)
+ & ~WS_BORDER, 0, 0, 0, 0, hwnd, NULL, hInst,0);
+
+ if (DBGetContactSettingByte(NULL,"CList","Transparent",0))
+ {
+ if(ServiceExists(MS_CLIST_FRAMES_ADDFRAME)) {
+
+ } else {
+#ifdef WS_EX_LAYERED
+ SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED);
+#endif
+#ifdef LWA_ALPHA
+ if (MySetLayeredWindowAttributes) MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), LWA_ALPHA);
+#endif
+ }
+ }
+
+ // timer to update titlebar
+ if(ServiceExists(MS_CLIST_FRAMES_ADDFRAME))
+ SetTimer(hwnd, TIMER_ID, 1000, TimerProc);
+
+ PostMessage(hwnd, WM_SIZE, 0, 0);
+ return TRUE;;
+
+ case WM_ACTIVATE:
+ if(wParam==WA_INACTIVE) {
+ if((HWND)wParam!=hwnd)
+ if(DBGetContactSettingByte(NULL,"CList","Transparent",SETTING_TRANSPARENT_DEFAULT))
+ if(transparentFocus)
+ SetTimer(hwnd, TM_AUTOALPHA,250,NULL);
+ }
+ else {
+ if(DBGetContactSettingByte(NULL,"CList","Transparent",SETTING_TRANSPARENT_DEFAULT)) {
+ KillTimer(hwnd,TM_AUTOALPHA);
+#ifdef LWA_ALPHA
+ if (MySetLayeredWindowAttributes) MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), LWA_ALPHA);
+#endif
+ transparentFocus=1;
+ }
+ }
+ return DefWindowProc(hwnd,msg,wParam,lParam);
+
+ case WM_SETCURSOR:
+ if(DBGetContactSettingByte(NULL,"CList","Transparent",SETTING_TRANSPARENT_DEFAULT)) {
+ if (!transparentFocus && GetForegroundWindow()!=hwnd && MySetLayeredWindowAttributes) {
+#ifdef LWA_ALPHA
+ MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), LWA_ALPHA);
+#endif
+ transparentFocus=1;
+ SetTimer(hwnd, TM_AUTOALPHA,250,NULL);
+ }
+ }
+ return DefWindowProc(hwnd,msg,wParam,lParam);
+
+ case WM_TIMER:
+ if ((int)wParam==TM_AUTOALPHA)
+ { int inwnd;
+
+ if (GetForegroundWindow()==hwnd) {
+ KillTimer(hwnd,TM_AUTOALPHA);
+ inwnd=1;
+ }
+ else {
+ POINT pt;
+ HWND hwndPt;
+ pt.x=(short)LOWORD(GetMessagePos());
+ pt.y=(short)HIWORD(GetMessagePos());
+ hwndPt=WindowFromPoint(pt);
+ inwnd=(hwndPt==hwnd || GetParent(hwndPt)==hwnd);
+ }
+ if (inwnd!=transparentFocus && MySetLayeredWindowAttributes)
+ { //change
+ transparentFocus=inwnd;
+#ifdef LWA_ALPHA
+ if(transparentFocus) MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), LWA_ALPHA);
+ else MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)DBGetContactSettingByte(NULL,"CList","AutoAlpha",SETTING_AUTOALPHA_DEFAULT), LWA_ALPHA);
+#endif
+ }
+ if(!transparentFocus) KillTimer(hwnd,TM_AUTOALPHA);
+ return TRUE;
+ }
+ return FALSE;
+
+ case WM_SHOWWINDOW:
+ { static int noRecurse=0;
+ if(lParam) break;
+ if(noRecurse) break;
+ if(!DBGetContactSettingByte(NULL,"CLUI","FadeInOut",0) || !IsWinVer2000Plus()) break;
+#ifdef WS_EX_LAYERED
+ if(GetWindowLong(hwnd,GWL_EXSTYLE)&WS_EX_LAYERED) {
+ DWORD thisTick,startTick;
+ int sourceAlpha,destAlpha;
+ if(wParam) {
+ sourceAlpha=0;
+ destAlpha=(BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_AUTOALPHA_DEFAULT);
+#ifdef LWA_ALPHA
+ MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), 0, LWA_ALPHA);
+#endif
+ noRecurse=1;
+ ShowWindow(hwnd,SW_SHOW);
+ noRecurse=0;
+ }
+ else {
+ sourceAlpha=(BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_AUTOALPHA_DEFAULT);
+ destAlpha=0;
+ }
+ for(startTick=GetTickCount();;) {
+ thisTick=GetTickCount();
+ if(thisTick>=startTick+200) break;
+#ifdef LWA_ALPHA
+ MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)(sourceAlpha+(destAlpha-sourceAlpha)*(int)(thisTick-startTick)/200), LWA_ALPHA);
+#endif
+ }
+#ifdef LWA_ALPHA
+ MySetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)destAlpha, LWA_ALPHA);
+#endif
+ }
+ else {
+// if(wParam) SetForegroundWindow(hwnd);
+ MyAnimateWindow(hwnd,200,AW_BLEND|(wParam?0:AW_HIDE));
+ //SetWindowPos(label,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_FRAMECHANGED);
+ }
+#endif
+ //int res = DefWindowProc(hwnd, msg, wParam, lParam);
+ //return res;
+ //break;
+ //return FALSE; //break;
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+ }
+
+ /*
+ case WM_PAINT:
+ {
+ paintDC = BeginPaint(hwnd, &paintStruct); //
+ //SelectObject(paintDC,TitleBarFont);
+ //SetBkMode(paintDC,TRANSPARENT);
+
+ //paintStruct.fErase=TRUE;
+ //color=RGB(1,1,1);
+ //brush=CreateSolidBrush(RGB(200,20,20));
+
+ //GetClientRect(hwnd,&rect);
+ //FillRect(paintDC,&rect,brush);
+ //TextOut(paintDC,4,4,"cl1 Bottom window",sizeof("cl1 Bottom window")-1);
+ //DeleteObject(brush);
+ EndPaint(hwnd, &paintStruct); //
+
+
+ };
+ return TRUE;
+
+ */
+ case WM_COMMAND:
+ //CreateServiceFunction("PingPlug/DisableAll", PingPlugDisableAll);
+ //CreateServiceFunction("PingPlug/EnableAll", PingPlugEnableAll);
+ switch(LOWORD(wParam)) {
+ case ID_MENU_GRAPH:
+ if(context_point_valid) {
+ WORD x = LOWORD(context_point),
+ y = HIWORD(context_point);
+ RECT r;
+ GetWindowRect(list_hwnd, &r);
+ DWORD item = SendMessage(list_hwnd, LB_ITEMFROMPOINT, 0, MAKELPARAM(x - r.left, y - r.top));
+ if(HIWORD(item) == 0) {
+ int count = LOWORD(item);
+ bool found = false;
+ Lock(&data_list_cs, "menu show graph");
+ if(count >= 0 && count < (int)data_list.size()) {
+ itemData = *(PINGADDRESS *)SendMessage(list_hwnd, LB_GETITEMDATA, count, 0);
+ found = true;
+ }
+ Unlock(&data_list_cs);
+ if(found)
+ CallService(PLUG "/ShowGraph", (WPARAM)itemData.item_id, (LPARAM)itemData.pszLabel);
+ }
+ }
+ return TRUE;
+ case ID_MENU_TOGGLE:
+ if(context_point_valid) {
+ WORD x = LOWORD(context_point),
+ y = HIWORD(context_point);
+ RECT r;
+ GetWindowRect(list_hwnd, &r);
+ DWORD item = SendMessage(list_hwnd, LB_ITEMFROMPOINT, 0, MAKELPARAM(x - r.left, y - r.top));
+ if(HIWORD(item) == 0) {
+ int count = LOWORD(item);
+ bool found = false;
+ Lock(&data_list_cs, "menu toggle");
+ if(count >= 0 && count < (int)data_list.size()) {
+ itemData = *(PINGADDRESS *)SendMessage(list_hwnd, LB_GETITEMDATA, count, 0);
+ found = true;
+ }
+ Unlock(&data_list_cs);
+ if(found)
+ CallService(PLUG "/ToggleEnabled", (WPARAM)itemData.item_id, 0);
+ }
+ }
+ return TRUE;
+ case ID_MENU_EDIT:
+ if(context_point_valid) {
+ WORD x = LOWORD(context_point),
+ y = HIWORD(context_point);
+ RECT r;
+ GetWindowRect(list_hwnd, &r);
+ DWORD item = SendMessage(list_hwnd, LB_ITEMFROMPOINT, 0, MAKELPARAM(x - r.left, y - r.top));
+ PINGADDRESS *temp = 0;
+ if(HIWORD(item) == 0) {
+ int count = LOWORD(item);
+ Lock(&data_list_cs, "menu edit");
+ if(count >= 0 && count < (int)data_list.size()) {
+ temp = (PINGADDRESS *)SendMessage(list_hwnd, LB_GETITEMDATA, count, 0);
+ }
+ Unlock(&data_list_cs);
+ if(temp) {
+ itemData = *temp;
+ if(Edit(hwnd, itemData)) {
+ Lock(&data_list_cs, "menu edited");
+ *temp = itemData;
+ CallService(PLUG "/SetAndSavePingList", (WPARAM)&data_list, 0);
+ Unlock(&data_list_cs);
+ }
+ }
+ }
+ }
+ return TRUE;
+ case ID_MENU_DISABLEALLPINGS:
+ CallService(PLUG "/DisableAll", 0, 0);
+ return TRUE;
+ case ID_MENU_ENABLEALLPINGS:
+ CallService(PLUG "/EnableAll", 0, 0);
+ return TRUE;
+ case ID_MENU_OPTIONS:
+ {
+ OPENOPTIONSDIALOG oop = {0};
+ oop.cbSize = sizeof(oop);
+ oop.pszGroup = "Network";
+ oop.pszPage = "PING";
+ oop.pszTab = "Settings";
+ Options_Open(&oop);
+ }
+ return TRUE;
+ case ID_MENU_DESTINATIONS:
+ {
+ OPENOPTIONSDIALOG oop = {0};
+ oop.cbSize = sizeof(oop);
+ oop.pszGroup = "Network";
+ oop.pszPage = "PING";
+ oop.pszTab = "Hosts";
+ Options_Open(&oop);
+ }
+ return TRUE;
+ }
+ if (HIWORD( wParam ) == LBN_DBLCLK) {
+ sel = SendMessage(list_hwnd, LB_GETCURSEL, 0, 0);
+ if(sel != LB_ERR) {
+ lp = SendMessage(list_hwnd, LB_GETITEMDATA, sel, 0);
+ if(lp != LB_ERR) {
+ PINGADDRESS *pItemData = (PINGADDRESS *)lp;
+
+ Lock(&data_list_cs, "command");
+
+ if(pItemData) {
+ DWORD item_id = pItemData->item_id;
+ Unlock(&data_list_cs);
+
+ int wake = CallService(PLUG "/DblClick", (WPARAM)item_id, 0);
+ InvalidateRect(list_hwnd, 0, FALSE);
+ if(wake) SetEvent(hWakeEvent);
+
+ if(options.logging) {
+ char buf[1024];
+ mir_snprintf(buf, 1024, "%s - %s", pItemData->pszLabel, (wake ? Translate("enabled") : Translate("double clicked")));
+ CallService(PLUG "/Log", (WPARAM)buf, 0);
+ }
+
+ } else {
+ Unlock(&data_list_cs);
+ }
+ }
+ }
+ return TRUE;
+ }
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+
+ case WM_MOVE: // needed for docked frames in clist_mw (not needed in clist_modern)
+ if(FrameIsFloating())
+ break;
+ case WM_SIZE:
+ {
+ //PostMessage(label, WM_SIZE, wParam, lParam);
+
+ GetClientRect(hwnd,&rect);
+ //SetWindowPos(list_hwnd, 0, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, SWP_NOZORDER);
+ //InvalidateRect(list_hwnd, &rect, FALSE);
+ int winheight = rect.bottom - rect.top,
+ itemheight = SendMessage(list_hwnd, LB_GETITEMHEIGHT, 0, 0),
+ count = SendMessage(list_hwnd, LB_GETCOUNT, 0, 0),
+#ifdef min
+ height = min(winheight - winheight % itemheight, itemheight * count);
+#else
+ height = std::min(winheight - winheight % itemheight, itemheight * count);
+#endif
+ SetWindowPos(list_hwnd, 0, rect.left, rect.top, rect.right-rect.left, height, SWP_NOZORDER);
+ InvalidateRect(list_hwnd, 0, FALSE);
+ }
+ InvalidateRect(hwnd, 0, TRUE);
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+
+ case WM_DESTROY:
+ if(!ServiceExists(MS_CLIST_FRAMES_ADDFRAME)) {
+ Utils_SaveWindowPosition(hwnd, 0, PLUG, "main_window");
+ }
+
+ KillTimer(hwnd, TIMER_ID);
+ if(tbrush) DeleteObject(tbrush);
+
+ DestroyWindow(list_hwnd);
+
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+
+ case WM_CLOSE:
+ if(!ServiceExists(MS_CLIST_FRAMES_ADDFRAME)) {
+ Utils_SaveWindowPosition(hwnd, 0, PLUG, "main_window");
+ ShowWindow(hwnd, SW_HIDE);
+ return 0;
+ }
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+/*
+ case WM_POWERBROADCAST:
+
+ if(options.logging) {
+ std::ostringstream oss;
+ switch(wParam) {
+ case PBT_APMSUSPEND:
+ CallService("PingPlug/Log", (WPARAM)"system suspend", 0);
+ break;
+ case PBT_APMRESUMESUSPEND:
+ oss << "system resume";
+ if(lParam == PBTF_APMRESUMEFROMFAILURE)
+ oss << " [suspend failure!]";
+ CallService("PingPlug/Log", (WPARAM)oss.str().c_str(), 0);
+ break;
+ case PBT_APMRESUMEAUTOMATIC:
+ oss << "system resume (automatic)";
+ if(lParam == PBTF_APMRESUMEFROMFAILURE)
+ oss << " [suspend failure!]";
+ CallService("PingPlug/Log", (WPARAM)oss.str().c_str(), 0);
+ break;
+ case PBT_APMRESUMECRITICAL:
+ oss << "system resume (critical)";
+ if(lParam == PBTF_APMRESUMEFROMFAILURE)
+ oss << " [suspend failure!]";
+ CallService("PingPlug/Log", (WPARAM)oss.str().c_str(), 0);
+ break;
+ }
+ }
+ break;
+*/
+ default:
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+
+ };
+
+ return(TRUE);
+};
+
+
+int ReloadFont(WPARAM wParam, LPARAM lParam) {
+ if(hFont) DeleteObject(hFont);
+
+ LOGFONT log_font;
+ CallService(MS_FONT_GET, (WPARAM)&font_id, (LPARAM)&log_font);
+ hFont = CreateFontIndirect(&log_font);
+ SendMessage(list_hwnd, WM_SETFONT, (WPARAM)hFont, (LPARAM)TRUE);
+
+ bk_col = CallService(MS_COLOUR_GET, (WPARAM)&bk_col_id, 0);
+ RefreshWindow(0, 0);
+
+ return 0;
+}
+
+int RefreshWindow(WPARAM wParam, LPARAM lParam) {
+ InvalidateRect(list_hwnd, 0, TRUE);
+ InvalidateRect(hpwnd, 0, TRUE);
+ return 0;
+}
+
+void UpdateFrame() {
+ if(IsWindowVisible(hwnd_clist) != IsWindowVisible(hpwnd))
+ ShowWindow(hpwnd, IsWindowVisible(hwnd_clist) ? SW_SHOW : SW_HIDE);
+
+ if(!IsWindowVisible(hpwnd)) return;
+
+ RECT r_clist;
+ GetWindowRect(hwnd_clist, &r_clist);
+ RECT r_frame;
+ GetWindowRect(hpwnd, &r_frame);
+ int height = list_size * options.row_height;
+ if(GetWindowLong(hpwnd, GWL_STYLE) & WS_BORDER) {
+ RECT r_frame_client;
+ GetClientRect(hpwnd, &r_frame_client);
+ height += (r_frame.bottom - r_frame.top) - (r_frame_client.bottom - r_frame_client.top);
+ }
+
+ SetWindowPos(hpwnd, 0, r_clist.left, r_clist.top - height, (r_clist.right - r_clist.left), height, SWP_NOZORDER | SWP_NOACTIVATE);
+}
+
+WNDPROC wpOrigClistProc;
+
+// Subclass procedure
+LRESULT APIENTRY ClistSubclassProc(
+ HWND hwnd,
+ UINT uMsg,
+ WPARAM wParam,
+ LPARAM lParam)
+{
+ if(uMsg == WM_SIZE || uMsg == WM_MOVE)
+ UpdateFrame();
+
+ if(uMsg == WM_NCCALCSIZE) { // possible window style change
+ if(GetWindowLong(hwnd_clist, GWL_STYLE) != GetWindowLong(hpwnd, GWL_STYLE)
+ || GetWindowLong(hwnd_clist, GWL_STYLE) != GetWindowLong(hpwnd, GWL_STYLE))
+ {
+ SetWindowLong(hpwnd, GWL_STYLE, GetWindowLong(hwnd_clist, GWL_STYLE));
+ SetWindowLong(hpwnd, GWL_EXSTYLE, GetWindowLong(hwnd_clist, GWL_EXSTYLE));
+ SetWindowPos(hpwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
+ }
+ }
+
+ if(uMsg == WM_SHOWWINDOW) {
+ ShowWindow(hpwnd, wParam);
+ }
+
+ return CallWindowProc(wpOrigClistProc, hwnd, uMsg, wParam, lParam);
+}
+
+void AttachToClist(bool attach) {
+ if(!hpwnd) return;
+
+ if(attach) {
+ SetWindowLong(hpwnd, GWL_STYLE, GetWindowLong(hwnd_clist, GWL_STYLE));
+ SetWindowLong(hpwnd, GWL_EXSTYLE, GetWindowLong(hwnd_clist, GWL_EXSTYLE));
+ SetWindowPos(hpwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
+
+ // subclass clist to trap move/size
+ wpOrigClistProc = (WNDPROC) SetWindowLongPtr(hwnd_clist, GWLP_WNDPROC, (LONG_PTR) ClistSubclassProc);
+
+ UpdateFrame();
+ } else {
+ SetWindowLong(hpwnd, GWL_STYLE, (WS_POPUPWINDOW | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_VISIBLE | WS_CLIPCHILDREN));
+ SetWindowLong(hpwnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);
+ SetWindowPos(hpwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
+
+ SetWindowLongPtr(hwnd_clist, GWLP_WNDPROC, (LONG_PTR) wpOrigClistProc);
+ }
+}
+
+void InitList() {
+
+ hUserDll = LoadLibrary(_T("user32.dll"));
+ if (hUserDll) {
+ MySetLayeredWindowAttributes = (BOOL (WINAPI *)(HWND,COLORREF,BYTE,DWORD))GetProcAddress(hUserDll, "SetLayeredWindowAttributes");
+ MyAnimateWindow=(BOOL (WINAPI*)(HWND,DWORD,DWORD))GetProcAddress(hUserDll,"AnimateWindow");
+ }
+
+ hwnd_clist = (HWND)CallService(MS_CLUI_GETHWND, 0, 0);
+
+ WNDCLASS wndclass;
+
+ wndclass.style = 0;
+ wndclass.lpfnWndProc = FrameWindowProc;
+ wndclass.cbClsExtra = 0;
+ wndclass.cbWndExtra = 0;
+ wndclass.hInstance = hInst;
+ wndclass.hIcon = hIconResponding;
+ wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
+ wndclass.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
+ wndclass.lpszMenuName = NULL;
+ wndclass.lpszClassName = PLUG "WindowClass";
+ RegisterClass(&wndclass);
+
+ if(ServiceExists(MS_CLIST_FRAMES_ADDFRAME)) {
+ hpwnd=CreateWindow(PLUG "WindowClass", "Ping", (WS_BORDER | WS_CHILD | WS_CLIPCHILDREN), 0, 0, 0, 0, hwnd_clist, NULL, hInst, NULL);
+
+ CLISTFrame frame = {0};
+ frame.name=PLUG;
+ frame.cbSize=sizeof(CLISTFrame);
+ frame.hWnd=hpwnd;
+ frame.align=alBottom;
+ frame.Flags=F_VISIBLE|F_SHOWTB|F_SHOWTBTIP;
+ frame.height=30;
+ frame.TBname=Translate("Ping");
+
+ frame_id=CallService(MS_CLIST_FRAMES_ADDFRAME,(WPARAM)&frame,0);
+ } else {
+ hpwnd=CreateWindowEx(WS_EX_TOOLWINDOW, PLUG "WindowClass","Ping",
+ (WS_POPUPWINDOW | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_CLIPCHILDREN),
+ 0,0,400,300,hwnd_clist,NULL,hInst,NULL);
+
+ Utils_RestoreWindowPosition(hpwnd, 0, PLUG, "main_window");
+
+ CreateServiceFunction(PLUG "/ShowWindow", PingPlugShowWindow);
+
+ CLISTMENUITEM mi = {0};
+
+ mi.flags = CMIF_TCHAR;
+ mi.popupPosition = 1000200001;
+ mi.ptszPopupName = LPGENT( "Ping" );
+ mi.cbSize = sizeof( mi );
+ mi.position = 3000320001;
+ mi.hIcon = 0;//LoadIcon( hInst, 0);
+ mi.ptszName = LPGENT( "Show/Hide &Ping Window" );
+ mi.pszService = PLUG "/ShowWindow";
+ Menu_AddMainMenuItem(&mi);
+
+ if(options.attach_to_clist) AttachToClist(true);
+ else ShowWindow(hpwnd, SW_SHOW);
+ }
+
+ {
+ font_id.cbSize = sizeof(FontID);
+ strncpy(font_id.group, "Ping", sizeof(font_id.group));
+ strncpy(font_id.name, "List", sizeof(font_id.name));
+ strncpy(font_id.dbSettingsGroup, "PING", sizeof(font_id.dbSettingsGroup));
+ strncpy(font_id.prefix, "Font", sizeof(font_id.prefix));
+ font_id.order = 0;
+
+ FontRegister(&font_id);
+
+ bk_col_id.cbSize = sizeof(ColourID);
+ strncpy(bk_col_id.group, "Ping", sizeof(bk_col_id.group));
+ strncpy(bk_col_id.name, "Background", sizeof(bk_col_id.name));
+ strncpy(bk_col_id.dbSettingsGroup, "PING", sizeof(bk_col_id.dbSettingsGroup));
+ strncpy(bk_col_id.setting, "BgColor", sizeof(bk_col_id.setting));
+ ColourRegister(&bk_col_id);
+
+ HookEvent(ME_FONT_RELOAD, ReloadFont);
+
+ ReloadFont(0, 0);
+ }
+
+ start_ping_thread();
+}
+
+void DeinitList() {
+ DestroyWindow(hpwnd);
+ stop_ping_thread();
+ if(hFont) DeleteObject(hFont);
+}
\ No newline at end of file diff --git a/plugins/Ping/src/pingthread.h b/plugins/Ping/src/pingthread.h new file mode 100644 index 0000000000..eda6dae61f --- /dev/null +++ b/plugins/Ping/src/pingthread.h @@ -0,0 +1,27 @@ +#ifndef _PINGTHREAD_H
+#define _PINGTHREAD_H
+
+#include "pinglist.h"
+#include "pinggraph.h"
+#include "utils.h"
+#include "options.h"
+
+extern HANDLE mainThread;
+extern HANDLE hWakeEvent;
+extern CRITICAL_SECTION thread_finished_cs, list_changed_cs, data_list_cs;
+
+extern PINGLIST data_list;
+
+int FillList(WPARAM wParam, LPARAM lParam);
+
+int RefreshWindow(WPARAM wParam, LPARAM lParam);
+
+void UpdateFrame();
+void AttachToClist(bool attach);
+
+void InitList();
+void DeinitList();
+
+#endif
+
+
diff --git a/plugins/Ping/src/rawping.cpp b/plugins/Ping/src/rawping.cpp new file mode 100644 index 0000000000..c5289dd16f --- /dev/null +++ b/plugins/Ping/src/rawping.cpp @@ -0,0 +1,217 @@ +#include "common.h"
+#include "rawping.h"
+
+//#define _WSPIAPI_COUNTOF
+#ifndef _MSC_VER
+#include <ws2tcpip.h>
+#endif
+
+USHORT ip_checksum(USHORT* buffer, int size)
+{
+ unsigned long cksum = 0;
+
+ // Sum all the words together, adding the final byte if size is odd
+ while (size > 1) {
+ cksum += *buffer++;
+ size -= sizeof(USHORT);
+ }
+ if (size) {
+ cksum += *(UCHAR*)buffer;
+ }
+
+ // Do a little shuffling
+ cksum = (cksum >> 16) + (cksum & 0xffff);
+ cksum += (cksum >> 16);
+
+ // Return the bitwise complement of the resulting mishmash
+ return (USHORT)(~cksum);
+}
+
+SOCKET sd = -1;
+char packet[1024];
+char recv_buff[1024];
+USHORT seq_no = 0;
+bool inited = false;
+
+extern int init_raw_ping() {
+ WSAData wsaData;
+ if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) {
+ WSACleanup();
+ return 1;
+ }
+
+ if(sd != -1)
+ closesocket(sd);
+
+ // Create the socket
+ //sd = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, 0, 0, 0);
+ sd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+ if (sd == INVALID_SOCKET) {
+ return 2;
+ }
+
+ int ttl = 255;
+ if (setsockopt(sd, IPPROTO_IP, IP_TTL, (const char*)&ttl, sizeof(ttl)) == SOCKET_ERROR) {
+ return 3;
+ }
+
+ int our_recv_timeout = 100; // so we ca do multiple recv calls
+ if(setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&our_recv_timeout, sizeof(int)) == SOCKET_ERROR) {
+ return 4;
+ }
+
+
+ ICMPHeader *header = (ICMPHeader *)packet;
+ header->type = PT_ICMP_ECHO_REQUEST;
+ header->code = 0;
+ header->id = (USHORT)GetCurrentProcessId();
+
+ inited = true;
+ if(raw_ping("127.0.0.1", 500) >= 0) {
+ return 0;
+ }
+
+ inited = false;
+ return 5;
+}
+
+extern int raw_ping(char *host, int timeout) {
+ if(!inited) return -1;
+
+ // Initialize the destination host info block
+ sockaddr_in dest;
+ memset(&dest, 0, sizeof(dest));
+
+ // Turn first passed parameter into an IP address to ping
+ unsigned int addr = inet_addr(host);
+ if (addr != INADDR_NONE) {
+ // It was a dotted quad number, so save result
+ dest.sin_addr.s_addr = addr;
+ dest.sin_family = AF_INET;
+ }
+ else {
+ // Not in dotted quad form, so try and look it up
+ hostent* hp = gethostbyname(host);
+ if (hp != 0) {
+ // Found an address for that host, so save it
+ memcpy(&(dest.sin_addr), hp->h_addr, hp->h_length);
+ //dest.sin_family = hp->h_addrtype;
+ dest.sin_family = AF_INET;
+ }
+ else {
+ // Not a recognized hostname either!
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: unrecognised host", 0);
+ return -1;
+ }
+ }
+
+ ICMPHeader *header = (ICMPHeader *)packet;
+ header->seq = ++seq_no;
+ header->checksum = 0;
+ header->checksum = ip_checksum((USHORT*)header, sizeof(ICMPHeader));
+
+ bool use_hi_res = false;
+ LARGE_INTEGER hr_freq, hr_send_time;
+ DWORD send_time;
+ if(QueryPerformanceFrequency(&hr_freq)) {
+ use_hi_res = true;
+ QueryPerformanceCounter(&hr_send_time);
+ } else
+ send_time = GetTickCount();
+
+ // send packet
+ int bwrote = sendto(sd, (char*)packet, sizeof(ICMPHeader), 0, (sockaddr*)&dest, sizeof(dest));
+ if (bwrote == SOCKET_ERROR) {
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: unable to send", 0);
+ return -1;
+ }
+
+ // Wait for the ping reply
+ sockaddr_in source;
+ int fromlen = sizeof(source);
+ IPHeader *reply_header = (IPHeader *)recv_buff;
+ ICMPHeader *reply;
+ DWORD start, current_time;
+ LARGE_INTEGER hr_start, hr_current_time, hr_timeout;
+ if(use_hi_res) {
+ hr_timeout.QuadPart = (timeout * hr_freq.QuadPart / 1000);
+ QueryPerformanceCounter(&hr_start);
+ hr_current_time = hr_start;
+ } else {
+ start = GetTickCount();
+ current_time = start;
+ }
+
+ while(((use_hi_res && (hr_current_time.QuadPart < hr_start.QuadPart + hr_timeout.QuadPart))
+ || (!use_hi_res && current_time < start + timeout)))
+ {
+ int bread = recvfrom(sd, recv_buff, 1024, 0, (sockaddr*)&source, &fromlen);
+
+ if(use_hi_res)
+ QueryPerformanceCounter(&hr_current_time);
+ else
+ current_time = GetTickCount();
+
+ if (bread == SOCKET_ERROR) {
+ if(WSAGetLastError() != WSAETIMEDOUT) {
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: socket error...cycling", 0);
+ }
+ continue;
+ }
+
+ if(reply_header->proto != ICMP_PROTO)
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: packet not ICMP...cycling", 0);
+ continue;
+
+ if(reply_header->tos != 0)
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: TOS not 0...cycling", 0);
+ continue;
+
+ reply = (ICMPHeader *)(recv_buff + reply_header->h_len * 4);
+ if((unsigned)bread < reply_header->h_len * 4 + sizeof(ICMPHeader)) {
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: short header", 0);
+ continue;
+ }
+
+ if(reply->id != (USHORT)GetCurrentProcessId())
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: wrong ID...cycling", 0);
+ continue;
+
+ if(reply->type != PT_ICMP_ECHO_REPLY && reply->type != PT_ICMP_SOURCE_QUENCH) {
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: wrong type...cycling", 0);
+ continue;
+ }
+
+ //if(reply->seq < seq_no) continue;
+ //if(reply->seq > seq_no) return -1;
+ if(reply->seq != seq_no) {
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: wrong sequence number...cycling", 0);
+ continue;
+ }
+
+ if(reply->type == PT_ICMP_SOURCE_QUENCH) {
+ char buff[1024];
+ sprintf(buff, Translate("Host %s requests that you reduce the amount of traffic you are sending."), host);
+ MessageBox(0, buff, Translate(PLUG " Warning"), MB_OK | MB_ICONWARNING);
+ }
+
+ if(use_hi_res) {
+ LARGE_INTEGER ticks;
+ ticks.QuadPart = hr_current_time.QuadPart - hr_send_time.QuadPart;
+ return (int)(ticks.QuadPart * 1000 / hr_freq.QuadPart);
+ } else
+ return current_time - send_time;
+ }
+ if(options.logging) CallService(PLUG "/Log", (WPARAM)"rawping error: timeout", 0);
+
+ return -1;
+}
+
+extern int cleanup_raw_ping() {
+ if(inited) {
+ closesocket(sd);
+ sd = -1;
+ WSACleanup();
+ }
+ return 0;
+}
diff --git a/plugins/Ping/src/rawping.h b/plugins/Ping/src/rawping.h new file mode 100644 index 0000000000..23d9df1d61 --- /dev/null +++ b/plugins/Ping/src/rawping.h @@ -0,0 +1,61 @@ +#ifndef _RAWPING_H
+#define _RAWPING_H
+
+#include "options.h"
+#include "log.h"
+
+
+// ICMP protocol identifier
+#define ICMP_PROTO 1
+
+// ICMP packet types
+#define PT_ICMP_ECHO_REPLY 0
+#define PT_ICMP_DEST_UNREACH 3
+#define PT_ICMP_TTL_EXPIRE 11
+#define PT_ICMP_ECHO_REQUEST 8
+#define PT_ICMP_SOURCE_QUENCH 4
+
+// Minimum ICMP packet size, in bytes
+#define ICMP_MIN 8
+
+#ifdef _MSC_VER
+// The following two structures need to be packed tightly, but unlike
+// Borland C++, Microsoft C++ does not do this by default.
+#pragma pack(1)
+#endif
+
+// The IP header
+struct IPHeader {
+ BYTE h_len:4; // Length of the header in dwords
+ BYTE version:4; // Version of IP
+ BYTE tos; // Type of service
+ USHORT total_len; // Length of the packet in dwords
+ USHORT ident; // unique identifier
+ USHORT flags; // Flags
+ BYTE ttl; // Time to live
+ BYTE proto; // Protocol number (TCP, UDP etc)
+ USHORT checksum; // IP checksum
+ ULONG source_ip;
+ ULONG dest_ip;
+};
+
+// ICMP header
+struct ICMPHeader {
+ BYTE type; // ICMP packet type
+ BYTE code; // Type sub code
+ USHORT checksum;
+ USHORT id;
+ USHORT seq;
+};
+
+#ifdef _MSC_VER
+#pragma pack()
+#endif
+
+extern USHORT ip_checksum(USHORT* buffer, int size);
+
+extern int init_raw_ping();
+extern int raw_ping(char *host, int timeout);
+extern int cleanup_raw_ping();
+
+#endif
diff --git a/plugins/Ping/src/resource.h b/plugins/Ping/src/resource.h new file mode 100644 index 0000000000..214edade09 --- /dev/null +++ b/plugins/Ping/src/resource.h @@ -0,0 +1,80 @@ +//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by ping.rc
+//
+#define IDD_DIALOG1 101
+#define IDD_DIALOG2 102
+#define IDD_DIALOG3 103
+#define IDR_MENU1 106
+#define IDI_ICON_PROTO 108
+#define IDI_ICON_DISABLED 112
+#define IDI_ICON_NOTRESPONDING 113
+#define IDI_ICON_RESPONDING 114
+#define IDI_ICON_TESTING 115
+#define IDC_PPM 1001
+#define IDC_PT 1002
+#define IDC_RPT 1003
+#define IDC_CHECK1 1005
+#define IDC_CHECKPOPUP 1005
+#define IDC_CHK_DESTTCP 1005
+#define IDC_BUTTONEDIT 1006
+#define IDC_BUTTONRELOAD 1007
+#define IDC_CHK_LOG 1008
+#define IDC_ED_FILENAME 1009
+#define IDC_CHECKPOPUP2 1010
+#define IDC_CHK_LOGCSV 1011
+#define IDC_CHK_BLOCK 1012
+#define IDC_BTN_VIEWLOG 1013
+#define IDC_ED_DATAFILENAME 1014
+#define IDC_BTN_LOGBROWSE 1015
+#define IDC_BTN_DATABROWSE 1016
+#define IDC_ED_DESTADDR 1016
+#define IDC_ED_DESTLAB 1017
+#define IDC_BTN_DESTADD 1018
+#define IDC_LST_DEST 1019
+#define IDC_BTN_DESTREM 1020
+#define IDC_ED_DESTPORT 1021
+#define IDC_BTN_DESTEDIT 1021
+#define IDC_ED_DESTPROTO 1022
+#define IDC_BTN_DESTUP 1022
+#define IDC_BTN_DESTDOWN 1023
+#define IDC_COMBO_DESTPROTO 1024
+#define IDC_COMBO_DESTSTAT 1025
+#define IDC_COMBO_DESTSTAT2 1026
+#define IDC_BGCOL 1031
+#define IDC_ED_COMMAND 1032
+#define IDC_STATFS 1032
+#define IDC_RSTATUS 1033
+#define IDC_ED_PARAMS 1033
+#define IDC_NRSTATUS 1034
+#define IDC_TSTATUS 1035
+#define IDC_EDIT1 1035
+#define IDC_DSTATUS 1036
+#define IDC_CHK_NOTESTSTATUS 1037
+#define IDC_CHK_NOTESTICON 1037
+#define IDC_COMBO_GROUP 1038
+#define IDC_CHK_HIDEPROTO 1038
+#define IDC_SP_INDENT 1038
+#define IDC_EDIT2 1039
+#define IDC_SP_ROWHEIGHT 1040
+#define IDC_CHK_ATTACH 1041
+#define IDC_CHK_MINMAX 1042
+#define IDC_ST_VER 1043
+#define ID_MENU_ENABLEALLPINGS 40002
+#define ID_MENU_OPTIONS 40003
+#define ID_MENU_DISABLEALLPINGS 40004
+#define ID_MENU_DESTINATIONS 40005
+#define ID_MENU_GRAPH 40006
+#define ID_MENU_TOGGLE 40007
+#define ID_MENU_EDIT 40008
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE 116
+#define _APS_NEXT_COMMAND_VALUE 40009
+#define _APS_NEXT_CONTROL_VALUE 1044
+#define _APS_NEXT_SYMED_VALUE 101
+#endif
+#endif
diff --git a/plugins/Ping/src/stdafx.cpp b/plugins/Ping/src/stdafx.cpp new file mode 100644 index 0000000000..7a516adf58 --- /dev/null +++ b/plugins/Ping/src/stdafx.cpp @@ -0,0 +1,18 @@ +/*
+Copyright (C) 2012 Miranda NG team (http://miranda-ng.org)
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation version 2
+of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
\ No newline at end of file diff --git a/plugins/Ping/src/utils.cpp b/plugins/Ping/src/utils.cpp new file mode 100644 index 0000000000..faf65423de --- /dev/null +++ b/plugins/Ping/src/utils.cpp @@ -0,0 +1,374 @@ +#include "common.h"
+#include "utils.h"
+#include "icmp.h"
+
+LRESULT CALLBACK NullWindowProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
+{
+ switch( message ) {
+ case WM_COMMAND: {
+ PUDeletePopUp( hWnd );
+ break;
+ }
+
+ case WM_CONTEXTMENU:
+ PUDeletePopUp( hWnd );
+ break;
+ }
+
+ return DefWindowProc(hWnd, message, wParam, lParam);
+}
+
+void CALLBACK sttMainThreadCallback( ULONG_PTR dwParam )
+{
+ POPUPDATAEX* ppd = ( POPUPDATAEX* )dwParam;
+
+ if ( ServiceExists(MS_POPUP_ADDPOPUPEX) )
+ PUAddPopUpEx(ppd);
+
+ free( ppd );
+}
+
+void __stdcall ShowPopup( const char* line1, const char* line2, int flags )
+{
+ if(CallService(MS_SYSTEM_TERMINATED, 0, 0)) return;
+
+ if ( ServiceExists( MS_POPUP_ADDPOPUP )) {
+ POPUPDATAEX* ppd = ( POPUPDATAEX* )calloc( sizeof( POPUPDATAEX ), 1 );
+
+ ppd->lchContact = NULL;
+ ppd->lchIcon = (flags ? hIconResponding : hIconNotResponding);
+ strncpy( ppd->lpzContactName, line1,MAX_CONTACTNAME);
+ strncpy( ppd->lpzText, line2, MAX_SECONDLINE);
+
+ ppd->colorBack = GetSysColor( COLOR_BTNFACE );
+ ppd->colorText = GetSysColor( COLOR_WINDOWTEXT );
+ ppd->iSeconds = 10;
+
+ ppd->PluginWindowProc = NullWindowProc;
+ ppd->PluginData = NULL;
+
+ QueueUserAPC( sttMainThreadCallback , mainThread, ( ULONG )ppd );
+ }
+ else if(ServiceExists(MS_POPUP_ADDPOPUPCLASS)) {
+ POPUPDATACLASS d = {sizeof(d), "pingpopups"};
+ d.pwszTitle = (wchar_t *)line1;
+ d.pwszText = (wchar_t *)line2;
+ CallService(MS_POPUP_ADDPOPUPCLASS, 0, (LPARAM)&d);
+ } else {
+ MessageBox( NULL, line2, PLUG " Message", MB_OK | MB_ICONINFORMATION );
+ return;
+ }
+}
+
+// service functions
+
+// wParam is zero
+// lParam is address of PINGADDRESS structure where ping result is placed (i.e. modifies 'responding'
+// and 'round_trip_time')
+INT_PTR PluginPing(WPARAM wParam,LPARAM lParam)
+{
+ PINGADDRESS *pa = (PINGADDRESS *)lParam;
+
+ if(pa->port == -1) {
+ // ICMP echo
+ if(use_raw_ping) {
+ pa->round_trip_time = raw_ping(pa->pszName, options.ping_timeout * 1000);
+ pa->responding = (pa->round_trip_time != -1);
+ } else {
+
+ ICMP_ECHO_REPLY result;
+ pa->responding = ICMP::get_instance()->ping(pa->pszName, result);
+ if(pa->responding)
+ pa->round_trip_time = (short)result.RoundTripTime;
+ else
+ pa->round_trip_time = -1;
+ }
+ } else if(hNetlibUser) {
+ // TCP connect
+
+ clock_t start_tcp = clock();
+
+ //GetLocalTime(&systime);
+ NETLIBOPENCONNECTION conn = {0};
+ conn.cbSize = sizeof(NETLIBOPENCONNECTION);
+ conn.szHost = pa->pszName;
+ conn.wPort = pa->port;
+ conn.timeout = options.ping_timeout;
+
+ HANDLE s = (HANDLE)CallService(MS_NETLIB_OPENCONNECTION, (WPARAM)hNetlibUser, (LPARAM)&conn);
+
+ clock_t end_tcp = clock();
+
+ if(s) {
+ LINGER l;
+ char buf[1024];
+ SOCKET socket = (SOCKET)CallService(MS_NETLIB_GETSOCKET, (WPARAM)s, (LPARAM)NLOCF_HTTP);
+ l.l_onoff = 1;
+ l.l_linger = 0;
+ setsockopt(socket, SOL_SOCKET, SO_LINGER, (char *)&l, sizeof(l));
+
+ Netlib_Send(s, "OUT\r\n\r\n", 7, 0); //MSG_RAW);
+
+ //Sleep(ICMP::get_instance()->get_timeout());
+ Sleep(options.ping_timeout * 1000);
+ unsigned long bytes_remaining;
+ ioctlsocket(socket, FIONBIO, &bytes_remaining);
+
+ if(bytes_remaining > 0) {
+ int retval, rx = 0;
+ while((retval = Netlib_Recv(s, buf, 1024, 0)) != SOCKET_ERROR && (retval > 0) && rx < 2048) {
+ rx += retval; // recv at most 2kb before closing connection
+ }
+ }
+ closesocket(socket);
+ pa->responding = true;
+ pa->round_trip_time = (int)(((end_tcp - start_tcp) / (double)CLOCKS_PER_SEC) * 1000);
+
+ Netlib_CloseHandle(s);
+ } else {
+ pa->responding = false;
+ pa->round_trip_time = -1;
+ }
+
+ }
+ return 0;
+}
+
+void Lock(CRITICAL_SECTION *cs, char *lab) {
+// if(logging) {
+// std::ostringstream oss1;
+// oss1 << "Locking cs: " << cs << ", " << lab;
+// CallService(PROTO "/Log", (WPARAM)oss1.str().c_str(), 0);
+// }
+ EnterCriticalSection(cs);
+// if(logging) {
+// std::ostringstream oss2;
+// oss2 << "Locked cs: " << cs;
+// CallService(PROTO "/Log", (WPARAM)oss2.str().c_str(), 0);
+// }
+}
+
+void Unlock(CRITICAL_SECTION *cs) {
+// if(logging) {
+// std::ostringstream oss1;
+// oss1 << "Unlocking cs: " << cs;
+// CallService(PROTO "/Log", (WPARAM)oss1.str().c_str(), 0);
+// }
+ LeaveCriticalSection(cs);
+}
+
+INT_PTR PingDisableAll(WPARAM wParam, LPARAM lParam) {
+ PINGLIST pl;
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+ for(PINGLIST::Iterator i = pl.start(); i.has_val(); i.next()) {
+ i.val().status = PS_DISABLED;
+ i.val().miss_count = 0;
+ }
+ CallService(PLUG "/SetPingList", (WPARAM)&pl, 0);
+ return 0;
+}
+
+INT_PTR PingEnableAll(WPARAM wParam, LPARAM lParam) {
+ PINGLIST pl;
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+ for(PINGLIST::Iterator i = pl.start(); i.has_val(); i.next()) {
+ if(i.val().status == PS_DISABLED) {
+ i.val().status = PS_NOTRESPONDING;
+ }
+ }
+ CallService(PLUG "/SetPingList", (WPARAM)&pl, 0);
+ return 0;
+}
+
+
+INT_PTR ToggleEnabled(WPARAM wParam, LPARAM lParam) {
+ int retval = 0;
+ PINGLIST pl;
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+ for(PINGLIST::Iterator i = pl.start(); i.has_val(); i.next()) {
+ if(i.val().item_id == (DWORD)wParam) {
+
+ if(i.val().status == PS_DISABLED)
+ i.val().status = PS_NOTRESPONDING;
+ else {
+ i.val().status = PS_DISABLED;
+ i.val().miss_count = 0;
+ retval = 1;
+ }
+ }
+ }
+ CallService(PLUG "/SetPingList", (WPARAM)&pl, 0);
+ return 0;
+}
+
+INT_PTR EditContact(WPARAM wParam, LPARAM lParam) {
+ PINGLIST pl;
+ HWND hwndList = (HWND)CallService(MS_CLUI_GETHWND, 0, 0);
+
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+ for(PINGLIST::Iterator i = pl.start(); i.has_val(); i.next()) {
+ if(i.val().item_id == (DWORD)wParam) {
+
+ add_edit_addr = i.val();
+
+ if(DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG3), hwndList, DlgProcDestEdit) == IDOK) {
+
+ i.val() = add_edit_addr;
+ CallService(PLUG "/SetAndSavePingList", (WPARAM)&pl, 0);
+ return 0;
+ }
+ }
+ }
+ return 1;
+}
+
+INT_PTR DblClick(WPARAM wParam, LPARAM lParam) {
+ PINGLIST pl;
+ CallService(PLUG "/GetPingList", 0, (LPARAM)&pl);
+ for(PINGLIST::Iterator i = pl.start(); i.has_val(); i.next()) {
+ if(i.val().item_id == (DWORD)wParam) {
+ if(strlen(i.val().pszCommand)) {
+ ShellExecute(0, "open", i.val().pszCommand, i.val().pszParams, 0, SW_SHOW);
+ } else {
+ return CallService(PLUG "/ToggleEnabled", wParam, 0);
+ }
+ }
+ }
+ return 0;
+}
+
+
+void import_ping_address(int index, PINGADDRESS &pa) {
+ DBVARIANT dbv;
+ char buf[256];
+ mir_snprintf(buf, 256, "Address%d", index);
+ if(!DBGetContactSetting(0, "PingPlug", buf, &dbv)) {
+ strncpy(pa.pszName, dbv.pszVal, MAX_PINGADDRESS_STRING_LENGTH);
+ DBFreeVariant(&dbv);
+ } else
+ strcpy(pa.pszName, Translate("Unknown Address"));
+
+ mir_snprintf(buf, 256, "Label%d", index);
+ if(!DBGetContactSetting(0, "PingPlug", buf, &dbv)) {
+ strncpy(pa.pszLabel, dbv.pszVal, MAX_PINGADDRESS_STRING_LENGTH);
+ DBFreeVariant(&dbv);
+ } else
+ strcpy(pa.pszLabel, Translate("Unknown"));
+
+ mir_snprintf(buf, 256, "Port%d", index);
+ pa.port = (int)DBGetContactSettingDword(0, "PingPlug", buf, -1);
+
+ mir_snprintf(buf, 256, "Proto%d", index);
+ if(!DBGetContactSetting(0, "PingPlug", buf, &dbv)) {
+ strncpy(pa.pszProto, dbv.pszVal, MAX_PINGADDRESS_STRING_LENGTH);
+ DBFreeVariant(&dbv);
+ mir_snprintf(buf, 256, "Status%d", index);
+ pa.set_status = DBGetContactSettingWord(0, "PingPlug", buf, ID_STATUS_ONLINE);
+ mir_snprintf(buf, 256, "Status2%d", index);
+ pa.get_status = DBGetContactSettingWord(0, "PingPlug", buf, ID_STATUS_OFFLINE);
+ } else
+ pa.pszProto[0] = '\0';
+
+
+ pa.responding = false;
+ pa.round_trip_time = 0;
+ pa.miss_count = 0;
+ pa.index = index;
+ pa.pszCommand[0] = '\0';
+ pa.pszParams[0] = '\0';
+
+ pa.item_id = 0;
+ mir_snprintf(buf, 256, "Enabled%d", index);
+ if(DBGetContactSettingByte(0, "PingPlug", buf, 1) == 1)
+ pa.status = PS_NOTRESPONDING;
+ else
+ pa.status = PS_DISABLED;
+}
+
+// read in addresses from old pingplug
+void import_ping_addresses() {
+ int count = DBGetContactSettingDword(0, "PingPlug", "NumEntries", 0);
+ PINGADDRESS pa;
+
+ EnterCriticalSection(&list_cs);
+ list_items.clear();
+ for(int index = 0; index < count; index++) {
+ import_ping_address(index, pa);
+ list_items.add(pa);
+ }
+ write_ping_addresses();
+ LeaveCriticalSection(&list_cs);
+}
+
+HANDLE hIcoLibIconsChanged;
+
+HICON hIconResponding, hIconNotResponding, hIconTesting, hIconDisabled;
+
+int ReloadIcons(WPARAM wParam, LPARAM lParam) {
+ hIconResponding = Skin_GetIcon("ping_responding");
+ hIconNotResponding = Skin_GetIcon("ping_not_responding");
+ hIconTesting = Skin_GetIcon("ping_testing");
+ hIconDisabled = Skin_GetIcon("ping_disabled");
+
+ RefreshWindow(0, 0);
+ return 0;
+}
+
+void InitUtils() {
+ TCHAR file[MAX_PATH];
+ GetModuleFileName(hInst,file,MAX_PATH);
+ {
+ SKINICONDESC sid = {0};
+
+ sid.cbSize = sizeof(SKINICONDESC);
+ sid.ptszSection = LPGENT("Ping");
+ sid.flags = SIDF_ALL_TCHAR;
+
+ sid.pszDescription = LPGENT("Responding");
+ sid.pszName = "ping_responding";
+ sid.ptszDefaultFile = file;
+ sid.iDefaultIndex = 0;
+ sid.hDefaultIcon = (HICON)LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_RESPONDING), IMAGE_ICON, 16, 16, 0);
+ Skin_AddIcon(&sid);
+
+ sid.pszDescription = LPGENT("Not Responding");
+ sid.pszName = "ping_not_responding";
+ sid.ptszDefaultFile = file;
+ sid.iDefaultIndex = 1;
+ sid.hDefaultIcon = (HICON)LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_NOTRESPONDING), IMAGE_ICON, 16, 16, 0);//LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS );
+ Skin_AddIcon(&sid);
+
+ sid.pszDescription = LPGENT("Testing");
+ sid.pszName = "ping_testing";
+ sid.ptszDefaultFile = file;
+ sid.iDefaultIndex = 2;
+ sid.hDefaultIcon = (HICON)LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TESTING), IMAGE_ICON, 16, 16, 0);//LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS );
+ Skin_AddIcon(&sid);
+
+ sid.pszDescription = LPGENT("Disabled");
+ sid.pszName = "ping_disabled";
+ sid.ptszDefaultFile = file;
+ sid.iDefaultIndex = 3;
+ sid.hDefaultIcon = (HICON)LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_DISABLED), IMAGE_ICON, 16, 16, 0);//LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS );
+ Skin_AddIcon(&sid);
+
+ hIconResponding = (HICON)CallService(MS_SKIN2_GETICON, 0, (LPARAM)"ping_responding");
+ hIconNotResponding = (HICON)CallService(MS_SKIN2_GETICON, 0, (LPARAM)"ping_not_responding");
+ hIconTesting = (HICON)CallService(MS_SKIN2_GETICON, 0, (LPARAM)"ping_testing");
+ hIconDisabled = (HICON)CallService(MS_SKIN2_GETICON, 0, (LPARAM)"ping_disabled");
+
+ hIcoLibIconsChanged = HookEvent(ME_SKIN2_ICONSCHANGED, ReloadIcons);
+ }
+
+ if(ServiceExists(MS_POPUP_REGISTERCLASS)) {
+ POPUPCLASS test = {0};
+ test.cbSize = sizeof(test);
+ test.flags = PCF_TCHAR;
+ test.hIcon = hIconResponding;
+ test.iSeconds = -1;
+ test.ptszDescription = TranslateT("Ping");
+ test.pszName = "pingpopups";
+ test.PluginWindowProc = NullWindowProc;
+ CallService(MS_POPUP_REGISTERCLASS, 0, (WPARAM)&test);
+ }
+}
\ No newline at end of file diff --git a/plugins/Ping/src/utils.h b/plugins/Ping/src/utils.h new file mode 100644 index 0000000000..0d27745908 --- /dev/null +++ b/plugins/Ping/src/utils.h @@ -0,0 +1,35 @@ +#ifndef _PING_UTILS
+#define _PING_UTILS
+
+#pragma warning( disable : 4786 )
+
+#include "pingthread.h" // for mainthread, for popup
+//#include "icmp.h"
+#include "rawping.h"
+#include "icmp.h"
+#include "options.h"
+
+void __stdcall ShowPopup( const char* line1, const char* line2, int flags );
+
+INT_PTR PluginPing(WPARAM wParam,LPARAM lParam);
+
+void Lock(CRITICAL_SECTION *cs, char *lab);
+void Unlock(CRITICAL_SECTION *cs);
+
+INT_PTR PingDisableAll(WPARAM wParam, LPARAM lParam);
+INT_PTR PingEnableAll(WPARAM wParam, LPARAM lParam);
+
+INT_PTR ToggleEnabled(WPARAM wParam, LPARAM lParam);
+
+INT_PTR DblClick(WPARAM wParam, LPARAM lParam);
+
+INT_PTR EditContact(WPARAM wParam, LPARAM lParam);
+// read in addresses from old pingplug
+void import_ping_addresses();
+
+// use icolib if possible
+void InitUtils();
+extern HICON hIconResponding, hIconNotResponding, hIconTesting, hIconDisabled;
+
+
+#endif
|