Remove obsolete / unused code
[gpgol.git] / src / watcher.cpp
1 /* watcher.cpp
2  * Copyright (C) 2005 g10 Code GmbH
3  *
4  * This file is part of GpgOL.
5  * 
6  * GpgOL is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  * 
11  * GpgOL is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  * 
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #error not anymore used.
21
22 #include <config.h>
23 #include <windows.h>
24 #include <stdio.h>
25 #include <gpgme.h>
26
27 #include "mymapi.h"
28 #include "myexchext.h"
29 #include "mymapitags.h"
30 #include "common.h"
31
32
33 /* Exchange callback context to retrieve the last message. */
34 static LPEXCHEXTCALLBACK g_cb = NULL;
35
36 /* The current hook handle. */
37 static HHOOK             g_cbt_hook = NULL;
38
39 /* MAPI message and storage handle. */
40 static LPMESSAGE         g_msg = NULL;
41 static LPMDB             g_mdb = NULL;
42 static HWND              g_creat_wnd = 0;
43
44 static HWND
45 find_message_window2 (HWND parent)
46 {
47   HWND child;
48
49   if (!parent)
50     return NULL;
51
52   child = GetWindow (parent, GW_CHILD);
53   while (child)
54     {
55       char buf[1024+1];
56       HWND w;
57       size_t len;
58       const char *s;
59       
60       memset (buf, 0, sizeof (buf));
61       GetWindowText (child, buf, sizeof (buf)-1);
62       len = strlen (buf);
63       if (len > 22
64           && (s = strstr (buf, "-----BEGIN PGP "))
65           &&  (!strncmp (s+15, "MESSAGE-----", 12)
66                || !strncmp (s+15, "SIGNED MESSAGE-----", 19)))
67         return child;
68       w = find_message_window2 (child);
69       if (w)
70         {
71           log_debug ("%s: watcher found message window: %p\n", __func__, w);
72           return w;
73         }
74       
75       child = GetNextWindow (child, GW_HWNDNEXT);       
76     }
77
78   return NULL;
79 }
80
81
82 /* Decrypt a single message. */
83 static void
84 decrypt_message (HWND hwnd, LPMESSAGE msg)
85 {
86   GpgMsg *m = CreateGpgMsg (msg);
87   m->setExchangeCallback ((void *)g_cb);
88   m->decrypt (hwnd, 0);
89   delete m;
90   UlRelease (msg);
91   msg = NULL;
92 }
93
94 /* This hook procedure allows to monitor all windows which are created
95  * and/or activated.
96  * We use it to find the new opened message window and start automatically
97  * the decryption code. The pre-condition is, that the new window has the
98  * proper window class and a child window with valid OpenPGP data.
99  *
100  * We cannot use the HCBT_CREATEWND alone because at the point the hook
101  * procedure is called, the window is only about to be created but the
102  * procedure has not finished yet. Plus the child windows are not yet
103  * created. Thus we check if the new window has the proper class. If
104  * this window is then activated, we call the decryption code and reset
105  * the window handle so the decryption is only called once.
106  */
107 static LRESULT CALLBACK
108 cbt_proc (int code, WPARAM w, LPARAM l)
109 {
110   char wclass[128];
111   HWND msgwnd, hwnd;
112
113   if (code < 0)
114     return CallNextHookEx (g_cbt_hook, code, w, l);
115   
116   hwnd = (HWND)w;
117   if (code == HCBT_CREATEWND)
118     {
119       GetClassName (hwnd, wclass, 127);
120       if (strstr (wclass, "rctrl_renwnd32"))
121         {
122           g_creat_wnd = hwnd;
123           log_debug ("%s: watch for window %p\n", __func__, hwnd);
124         }
125       
126     }
127   
128   if (code == HCBT_ACTIVATE && g_creat_wnd == hwnd)
129     {
130       log_debug ("%s: %p == %p?\n", __func__, g_creat_wnd, hwnd);
131       g_creat_wnd = NULL;
132       msgwnd = find_message_window2 (hwnd);
133       if (msgwnd && g_msg)
134         {
135           log_debug ("%s: decrypt_message(%p, %p)\n", __func__, hwnd, g_msg);
136           decrypt_message (hwnd, g_msg);
137           UlRelease (g_mdb); 
138           g_mdb = NULL;
139         }
140     }
141
142     return CallNextHookEx (g_cbt_hook, code, w, l);
143 }
144
145
146 /* Initialize the CBT hook. */
147 extern "C" int
148 watcher_init_hook (void)
149 {
150   if (g_cbt_hook != NULL)
151     return 0;
152   g_cbt_hook = SetWindowsHookEx (WH_CBT, cbt_proc, glob_hinst, 0);
153   if (!g_cbt_hook)
154     {
155       log_debug ("%s: SetWindowsHookEx failed ec=%d\n", 
156                  __func__, (int)GetLastError ());
157       return -1;
158     }  
159   return 0;
160 }
161
162
163 /* Remove the CBT hook. */
164 extern "C" int
165 watcher_free_hook (void)
166 {
167   if (g_msg != NULL) 
168     {
169       UlRelease (g_msg);
170       g_msg = NULL;
171     }
172   if (g_mdb != NULL) 
173     {
174       UlRelease (g_mdb);
175       g_mdb = NULL;
176     }
177   if (g_cbt_hook != NULL)
178     {
179       UnhookWindowsHookEx (g_cbt_hook);
180       g_cbt_hook = NULL;
181     }  
182   return 0;
183 }
184
185
186 /* Set the Exchange callback context. */
187 extern "C" void
188 watcher_set_callback_ctx (void *cb)
189 {     
190   HRESULT hr;
191   
192   g_cb = (LPEXCHEXTCALLBACK)cb;
193
194   if (g_msg != NULL)
195     UlRelease (g_msg);
196   if (g_mdb != NULL)
197     UlRelease (g_mdb);
198   hr = g_cb->GetObject (&g_mdb, (LPMAPIPROP *)&g_msg);
199   if (FAILED (hr)) 
200     {
201       log_debug ("%s: GetObject() failed ec=%lx\n", __func__, hr);
202       g_mdb = NULL;
203       g_msg = NULL;
204     }
205 }