/[rdesktop]/sourceforge.net/trunk/seamlessrdp/ServerExe/HookDll/hookdll.cpp
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/seamlessrdp/ServerExe/HookDll/hookdll.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 918 by astrand, Thu Jun 30 08:53:04 2005 UTC revision 999 by astrand, Tue Aug 30 09:18:53 2005 UTC
# Line 1  Line 1 
1  //*********************************************************************************  //
2  //  // Copyright (C) 2004-2005 Martin Wickett
3  //Title: Terminal Services Window Clipper  //
4  //  
5  //Author: Martin Wickett  #include "hookdll.h"
6  //  #include <windows.h>
7  //Date: 2004  #include <winuser.h>
8  //  #include <stdio.h>
9  //*********************************************************************************  #include <stdarg.h>
10    
11  #include "hookdll.h"  #include "wtsapi32.h"
12  #include <windows.h>  #include "Cchannel.h"
13  #include <winuser.h>  
14    #define DLL_EXPORT extern "C" __declspec(dllexport)
15  #include "wtsapi32.h"  
16  #include "Cchannel.h"  // Shared DATA
17    #pragma data_seg ( "SHAREDDATA" )
18  #define DLL_EXPORT extern "C" __declspec(dllexport)  
19    // this is the total number of processes this dll is currently attached to
20  // Shared DATA  int iInstanceCount = 0;
21  #pragma data_seg ( "SHAREDDATA" )  HWND hWnd = 0;
22    
23          // this is the total number of processes this dll is currently attached to  #pragma data_seg ()
24          int                             iInstanceCount          = 0;  
25          HWND                    hWnd                            = 0;  #pragma comment(linker, "/section:SHAREDDATA,rws")
26    
27  #pragma data_seg ()  #define snprintf _snprintf
28    
29  #pragma comment(linker, "/section:SHAREDDATA,rws")  bool bHooked = false;
30    bool bHooked2 = false;
31  bool                    bHooked        = false;  bool bHooked3 = false;
32  bool                    bHooked2       = false;  HHOOK hhook = 0; //cbt
33  bool                    bHooked3       = false;  HHOOK hhook2 = 0; //shell
34  HHOOK                   hhook          = 0;//cbt  HHOOK hhook3 = 0; //wnd proc
35  HHOOK                   hhook2         = 0;//shell  HINSTANCE hInst = 0;
36  HHOOK                   hhook3             = 0;//wnd proc  HANDLE m_vcHandle = 0;
37  HINSTANCE               hInst          = 0;  
38  HANDLE                  m_vcHandle         = 0;  
39    void SendDebug( char *format, ... )
40  BOOL APIENTRY DllMain( HINSTANCE hinstDLL, DWORD  ul_reason_for_call, LPVOID lpReserved )  {
41  {      va_list argp;
42      switch (ul_reason_for_call)      char buf [ 256 ];
43          {      
44                  case DLL_PROCESS_ATTACH:      va_start( argp, format );
45                          {      vsprintf( buf, format, argp );
46                                  // remember our instance handle      va_end( argp );
47                                  hInst = hinstDLL;      
48                                  ++iInstanceCount;      if ( ChannelIsOpen() ) {
49                                  OpenVirtualChannel();          WriteToChannel( "DEBUG1," );
50                                   break;          WriteToChannel( buf );
51                          }          WriteToChannel( "\n" );
52        }
53                  case DLL_THREAD_ATTACH:  }
54                                  break;  
55                  case DLL_THREAD_DETACH:  
56                          break;  
57                  case DLL_PROCESS_DETACH:  BOOL APIENTRY DllMain( HINSTANCE hinstDLL, DWORD ul_reason_for_call, LPVOID lpReserved )
58                          {  {
59                                  --iInstanceCount;      switch ( ul_reason_for_call ) {
60                                  CloseVirtualChannel();          case DLL_PROCESS_ATTACH: {
61                          }              // remember our instance handle
62                          break;              hInst = hinstDLL;
63      }              ++iInstanceCount;
64                OpenVirtualChannel();
65      return TRUE;              break;
66  }          }
67            
68  LRESULT CALLBACK CallWndProc(int nCode, WPARAM wParam, LPARAM lParam )          case DLL_THREAD_ATTACH:
69  {          break;
70          if (nCode<0)          case DLL_THREAD_DETACH:
71          {          break;
72                  return CallNextHookEx(hhook3, nCode, wParam, lParam);          case DLL_PROCESS_DETACH: {
73          }              --iInstanceCount;
74                CloseVirtualChannel();
75          PCHAR buffer          = NULL;          }
76          char windowTitle[150] = {""};          break;
77          HWND windowHandle     = NULL;      }
78          char result[255]      = {""};      
79          char strWindowId[25];      return TRUE;
80          char type[25];  }
81    
82          LONG b,t,l,r;  LRESULT CALLBACK CallWndProc( int nCode, WPARAM wParam, LPARAM lParam )
83      char strB[5];  {
84          char strT[5];      if ( nCode < 0 ) {
85          char strL[5];          return CallNextHookEx( hhook3, nCode, wParam, lParam );
86      char strR[5];      }
87          RECT rect;      
88        PCHAR buffer = NULL;
89          CWPSTRUCT* details = (CWPSTRUCT*) lParam;      char windowTitle[ 150 ] = { ""
90                                  };
91          switch( details->message )      HWND windowHandle = NULL;
92          {            HWND windowHandle2 = NULL;
93                  case WM_SIZING:      char result[ 255 ] = { ""
94                  case WM_MOVING:                           };
95                                char strWindowId[ 25 ];
96                          windowHandle = details->hwnd;      char type[ 25 ];
97                          //get win name      
98                          GetWindowText(windowHandle,windowTitle,150);      LONG b, t, l, r;
99                                char strX[ 5 ];
100                          //get an id for it      char strY[ 5 ];
101                          itoa((int)windowHandle, strWindowId, 10);      char strW[ 5 ];
102                                char strH[ 5 ];
103                          //get coords      
104                          GetWindowRect(windowHandle,&rect);      CWPSTRUCT *details = ( CWPSTRUCT * ) lParam;
105                          b = rect.bottom;      CREATESTRUCT *cs = ( CREATESTRUCT * ) details->lParam;
106                          t = rect.top;      LONG dwStyle = GetWindowLong( details->hwnd, GWL_STYLE );
107                          l = rect.left;      WINDOWPOS *wp = ( WINDOWPOS * ) details->lParam;
108                          r = rect.right;      RECT *rect = ( RECT * ) details->lParam;
109                          ltoa(b,strB,10);      
110                          ltoa(t,strT,10);      switch ( details->message ) {
111                          ltoa(r,strR,10);      
112                          ltoa(l,strL,10);          case WM_SIZING:
113            case WM_MOVING:
114                          ////setup return string          snprintf( result, sizeof( result ),
115                          strcat(result, "MSG=CALLWNDPROC_WM_MOVING;");                    "POSITION1,0x%x,%d,%d,%d,%d,0x%x",
116                          strcat( result, "ID=" );                    ( int ) details->hwnd,
117                          strcat( result, strWindowId );                    rect->left, rect->top,
118                          strcat( result, ";" );                    rect->right - rect->left,
119                          strcat( result, "TITLE=" );                    rect->bottom - rect->top,
120                          strcat( result, windowTitle);                    0 );
121                          strcat( result, ";" );          result[ sizeof( result ) - 1 ] = '\0';
122                          strcat( result, "POS=" );          buffer = result;
123                          strcat( result, strL);          
124                          strcat( result, "~");          break;
125                          strcat( result, strT);          
126                          strcat( result, "~");          /* Note: WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED are
127                          strcat( result, strR);          strange. Sometimes, for example when bringing up the
128                          strcat( result, "~");          Notepad About dialog, only an WM_WINDOWPOSCHANGING is
129                          strcat( result, strB);          sent. In some other cases, for exmaple when opening
130                          strcat( result, ";" );          Format->Text in Notepad, both events are sent. Also, for
131                                    some reason, when closing the Notepad About dialog, an
132                          buffer = result;          WM_WINDOWPOSCHANGING event is sent which looks just like
133                            the event that was sent when the About dialog was opened...  */
134                  break;          case WM_WINDOWPOSCHANGING:
135            
136                  default:          if ( !( dwStyle & WS_VISIBLE ) )
137                          break;              break;
138          }              
139            if ( !( dwStyle & WS_DLGFRAME ) )
140          if (ChannelIsOpen())              break;
141          {              
142                  if ( buffer != NULL)          if ( !( wp->flags & SWP_NOZORDER ) ) {
143                  {              snprintf( result, sizeof( result ),
144                          WriteToChannel(buffer);                        "ZCHANGE1,0x%x,0x%x,0x%x\n",
145                  }                        details->hwnd,
146          }                        wp->flags & SWP_NOACTIVATE ? wp->hwndInsertAfter : 0,
147                          0 );
148          return CallNextHookEx(hhook3, nCode, wParam, lParam);              result[ sizeof( result ) - 1 ] = '\0';
149  }          }
150            buffer = result;
151  LRESULT CALLBACK CbtProc(int nCode, WPARAM wParam, LPARAM lParam )          
152  {          break;
153          if (nCode<0)          
154          {          
155                  return CallNextHookEx(hhook, nCode, wParam, lParam);          case WM_CREATE:
156          }          if ( cs->style & WS_DLGFRAME ) {
157                sprintf( result, "DEBUG:WM_CREATE:%dx%d at %d,%d, title=%s, menu=%p, window=%p, WS_BORDER=%d, WS_DLGFRAME=%d, WS_POPUP=%d",
158                         cs->cx, cs->cy, cs->x, cs->y, cs->lpszName, cs->hMenu, details->hwnd,
159                  PCHAR buffer          = NULL;                       cs->style & WS_BORDER, cs->style & WS_DLGFRAME,
160                         cs->style & WS_POPUP );
161                buffer = result;
162                  char windowTitle[150] = {""};          }
163                  HWND windowHandle     = NULL;          
164                  char result[255]      = {""};          break;
165                  char strWindowId[25];          
166                  char type[25];          
167            case WM_DESTROY:
168            if ( dwStyle & WS_DLGFRAME ) {
169                  LONG b,t,l,r;              sprintf( result, "WM_DESTROY:%p", details->hwnd );
170          char strB[5];              buffer = result;
171                  char strT[5];          }
172              char strL[5];          
173          char strR[5];          break;
174                  RECT rect;          
175            default:
176                  int i = 0;//tmp          break;
177                }
178                  switch( nCode )      
179                  {      if ( ChannelIsOpen() ) {
180                          case HCBT_MINMAX:          if ( buffer != NULL ) {
181                WriteToChannel( buffer );
182                                  windowHandle = (HWND)wParam;          }
183                                  //get win name      }
184                                  GetWindowText(windowHandle,windowTitle,150);      
185                                        return CallNextHookEx( hhook3, nCode, wParam, lParam );
186                                  //get an id for it  }
187                                  itoa((int)windowHandle, strWindowId, 10);  
188                                    LRESULT CALLBACK CbtProc( int nCode, WPARAM wParam, LPARAM lParam )
189                                  //get operation type(min,max). if max, do not clip at all,if min use window's previous coords  {
190                                  //codes are:      if ( nCode < 0 ) {
191            return CallNextHookEx( hhook, nCode, wParam, lParam );
192                                  // SW_HIDE= 0  SW_SHOWNORMAL=1  SW_NORMAL=1  SW_SHOWMINIMIZED=2  SW_SHOWMAXIMIZED=3  SW_MAXIMIZE=3      }
193                                  // SW_SHOWNOACTIVATE=4  SW_SHOW=5  SW_MINIMIZE=6  SW_SHOWMINNOACTIVE=7  SW_SHOWNA=8  SW_RESTORE=9        
194                                  // SW_SHOWDEFAULT=10  SW_FORCEMINIMIZE=11  SW_MAX=11          
195        PCHAR buffer = NULL;
196                                  itoa((int)lParam, type, 10);      
197        
198                                  //get coords      char windowTitle[ 150 ] = { ""
199                                  GetWindowRect(windowHandle,&rect);                                };
200                                  b = rect.bottom;      HWND windowHandle = NULL;
201                                  t = rect.top;      char result[ 255 ] = { ""
202                                  l = rect.left;                           };
203                                  r = rect.right;      char strWindowId[ 25 ];
204                                  ltoa(b,strB,10);      char type[ 25 ];
205                                  ltoa(t,strT,10);      
206                                  ltoa(r,strR,10);      
207                                  ltoa(l,strL,10);      LONG b, t, l, r;
208        char strW[ 5 ];
209                                  //get name      char strY[ 5 ];
210                                  GetWindowText(windowHandle,windowTitle,150);      char strX[ 5 ];
211        char strH[ 5 ];
212                                  ////setup return string      RECT rect;
213                                  strcat(result, "MSG=HCBT_MINMAX;");      
214                                  strcat( result, "ID=" );      int i = 0; //tmp
215                                  strcat( result, strWindowId );      
216                                  strcat( result, ";" );      switch ( nCode ) {
217                                  strcat( result, "TITLE=" );          case HCBT_MINMAX:
218                                  strcat( result, windowTitle);          
219                                  strcat( result, ";" );          windowHandle = ( HWND ) wParam;
220                                  strcat( result, "POS=" );          //get win name
221                                  strcat( result, strL);          GetWindowText( windowHandle, windowTitle, 150 );
222                                  strcat( result, "~");          
223                                  strcat( result, strT);          //get an id for it
224                                  strcat( result, "~");          itoa( ( int ) windowHandle, strWindowId, 10 );
225                                  strcat( result, strR);          
226                                  strcat( result, "~");          //get operation type(min,max). if max, do not clip at all,if min use window's previous coords
227                                  strcat( result, strB);          //codes are:
228                                  strcat( result, ";" );          
229                                  strcat( result, "TYPE=" );          // SW_HIDE= 0  SW_SHOWNORMAL=1  SW_NORMAL=1  SW_SHOWMINIMIZED=2  SW_SHOWMAXIMIZED=3  SW_MAXIMIZE=3
230                                  strcat( result, type );          // SW_SHOWNOACTIVATE=4  SW_SHOW=5  SW_MINIMIZE=6  SW_SHOWMINNOACTIVE=7  SW_SHOWNA=8  SW_RESTORE=9
231                                  strcat( result, ";" );          // SW_SHOWDEFAULT=10  SW_FORCEMINIMIZE=11  SW_MAX=11
232            
233                                  //-------------------------------------------------------------------------------------------------          itoa( ( int ) lParam, type, 10 );
234                                  // code to prevent minimising windows (can be removed once minimise has been implemented)          
235                                  i = (int)lParam;          //get coords
236                                  //if (i==0 || i==2 || i==6 || i==7 || i==8 || i==11)          GetWindowRect( windowHandle, &rect );
237                                  if ( i==2 || i==6 )          b = rect.bottom;
238                                  {          t = rect.top;
239                                          MessageBox(0,"Minimising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);          l = rect.left;
240                                          return 1;          r = rect.right;
241                                  }          ltoa( b - t, strW, 10 );
242                                  //-----------------------------------------------------------------------------------------          ltoa( t, strY, 10 );
243            ltoa( r - l, strH, 10 );
244                                  //-------------------------------------------------------------------------------------------------          ltoa( l, strX, 10 );
245                                  // code to prevent maximising windows (can be removed once maximise has been implemented)          
246                                  i = (int)lParam;          //get name
247                                  //if (i==3 || i==9 || i==11)          GetWindowText( windowHandle, windowTitle, 150 );
248                                  if (i==3 || i==11)          
249                                  {          ////setup return string
250                                          MessageBox(0,"Maximising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);          strcat( result, "MSG=HCBT_MINMAX;OP=4;" );
251                                          return 1;          
252                                  }          // SW_SHOWNOACTIVATE=4  SW_SHOW=5  SW_MINIMIZE=6  SW_SHOWMINNOACTIVE=7  SW_SHOWNA=8  SW_RESTORE=9
253                                  //-----------------------------------------------------------------------------------------          // SW_SHOWDEFAULT=10  SW_FORCEMINIMIZE=11  SW_MAX=11
254            strcat( result, "ID=" );
255                                  buffer = result;          strcat( result, strWindowId );
256            strcat( result, ";" );
257                                  break;          strcat( result, "TITLE=" );
258            strcat( result, windowTitle );
259                          case HCBT_MOVESIZE:          strcat( result, ";" );
260                    strcat( result, "X=" );
261                                  windowHandle = (HWND)wParam;          strcat( result, strX );
262                                  //get win name          strcat( result, ";" );
263                                  GetWindowText(windowHandle,windowTitle,150);          strcat( result, "Y=" );
264                                            strcat( result, strY );
265                                  //get an id for it          strcat( result, ";" );
266                                  itoa((int)windowHandle, strWindowId, 10);          strcat( result, "H=" );
267            strcat( result, strH );
268                                  //get coords          strcat( result, ";" );
269                                  GetWindowRect(windowHandle,&rect);          strcat( result, "W=" );
270                                  b = rect.bottom;          strcat( result, strW );
271                                  t = rect.top;          strcat( result, ";" );
272                                  l = rect.left;          strcat( result, "TYPE=" );
273                                  r = rect.right;          strcat( result, type );
274                                  ltoa(b,strB,10);          strcat( result, "." );
275                                  ltoa(t,strT,10);          
276                                  ltoa(r,strR,10);          //-------------------------------------------------------------------------------------------------
277                                  ltoa(l,strL,10);          // code to prevent minimising windows (can be removed once minimise has been implemented)
278            //i = (int)lParam;
279                                  //get name          //if (i==0 || i==2 || i==6 || i==7 || i==8 || i==11)
280                                  GetWindowText(windowHandle,windowTitle,150);          //if ( i==2 || i==6 )
281            //{
282                                  ////setup return string          // MessageBox(0,"Minimising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);
283                                  strcat(result, "MSG=HCBT_MOVESIZE;");          // return 1;
284                                  strcat( result, "ID=" );          //}
285                                  strcat( result, strWindowId );          //-----------------------------------------------------------------------------------------
286                                  strcat( result, ";" );          
287                                  strcat( result, "TITLE=" );          //-------------------------------------------------------------------------------------------------
288                                  strcat( result, windowTitle);          // code to prevent maximising windows (can be removed once maximise has been implemented)
289                                  strcat( result, ";" );          //i = (int)lParam;
290                                  strcat( result, "POS=" );          //if (i==3 || i==9 || i==11)
291                                  strcat( result, strL);          //if (i==3 || i==11)
292                                  strcat( result, "~");          //{
293                                  strcat( result, strT);          // MessageBox(0,"Maximising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);
294                                  strcat( result, "~");          // return 1;
295                                  strcat( result, strR);          //}
296                                  strcat( result, "~");          //-----------------------------------------------------------------------------------------
297                                  strcat( result, strB);          
298                                  strcat( result, ";" );          buffer = result;
299            
300                                  buffer = result;          break;
301            
302                                  break;          default:
303                          case HCBT_SETFOCUS:          break;
304                                  //buffer = "HCBT_SETFOCUS";      }
305                                  //not needed yet      
306                          break;      if ( ChannelIsOpen() ) {
307                          default:          if ( buffer != NULL ) {
308                                  break;              WriteToChannel( buffer );
309                  }          }
310        }
311          if (ChannelIsOpen())      
312          {      return CallNextHookEx( hhook, nCode, wParam, lParam );
313                  if ( buffer != NULL)  }
314                  {  
315                          WriteToChannel(buffer);  
316                  }  LRESULT CALLBACK ShellProc( int nCode, WPARAM wParam, LPARAM lParam )
317          }  {
318        if ( nCode < 0 ) {
319          return CallNextHookEx(hhook, nCode, wParam, lParam);          return CallNextHookEx( hhook, nCode, wParam, lParam );
320  }      }
321        
322        if ( ChannelIsOpen() ) {
323  LRESULT CALLBACK ShellProc(int nCode, WPARAM wParam, LPARAM lParam )          PCHAR buffer = NULL;
324  {          
325          if (nCode<0)          char windowTitle[ 150 ] = { ""
326          {                                    };
327                  return CallNextHookEx(hhook, nCode, wParam, lParam);          HWND windowHandle = NULL;
328          }          char result[ 255 ] = { ""
329                                 };
330          if (ChannelIsOpen())          char strWindowId[ 25 ];
331          {          LONG b, t, l, r;
332                  PCHAR buffer          = NULL;          char strW[ 5 ];
333            char strY[ 5 ];
334                  char windowTitle[150] = {""};          char strX[ 5 ];
335                  HWND windowHandle     = NULL;          char strH[ 5 ];
336                  char result[255]      = {""};          RECT rect;
337                  char strWindowId[25];          
338                  LONG b,t,l,r;          switch ( nCode ) {
339          char strB[5];              case HSHELL_WINDOWCREATED:
340                  char strT[5];              
341              char strL[5];              //get window id
342          char strR[5];              windowHandle = ( HWND ) wParam;
343                  RECT rect;              itoa( ( int ) windowHandle, strWindowId, 10 );
344                
345                  switch( nCode )              //get coords
346                          {              GetWindowRect( windowHandle, &rect );
347                                  case HSHELL_WINDOWCREATED:              b = rect.bottom;
348                                                        t = rect.top;
349                                          //get window id              l = rect.left;
350                                          windowHandle = (HWND) wParam;              r = rect.right;
351                                          itoa((int)windowHandle, strWindowId, 10);              ltoa( b - t, strH, 10 );
352                ltoa( t, strY, 10 );
353                                          //get coords              ltoa( r - l, strW, 10 );
354                                          GetWindowRect(windowHandle,&rect);              ltoa( l, strX, 10 );
355                                          b = rect.bottom;              
356                                          t = rect.top;              //get name
357                                          l = rect.left;              GetWindowText( windowHandle, windowTitle, 150 );
358                                          r = rect.right;              
359                                          ltoa(b,strB,10);              ////setup return string
360                                          ltoa(t,strT,10);              strcat( result, "MSG=HSHELL_WINDOWCREATED;OP=0;" );
361                                          ltoa(r,strR,10);              strcat( result, "ID=" );
362                                          ltoa(l,strL,10);              strcat( result, strWindowId );
363                strcat( result, ";" );
364                                          //get name              strcat( result, "TITLE=" );
365                                          GetWindowText(windowHandle,windowTitle,150);              strcat( result, windowTitle );
366                strcat( result, ";" );
367                                          ////setup return string              strcat( result, "X=" );
368                                          strcat(result, "MSG=HSHELL_WINDOWCREATED;");              strcat( result, strX );
369                                          strcat( result, "ID=" );              strcat( result, ";" );
370                                          strcat( result, strWindowId );              strcat( result, "Y=" );
371                                          strcat( result, ";" );              strcat( result, strY );
372                                          strcat( result, "TITLE=" );              strcat( result, ";" );
373                                          strcat( result, windowTitle);              strcat( result, "H=" );
374                                          strcat( result, ";" );              strcat( result, strH );
375                                          strcat( result, "POS=" );              strcat( result, ";" );
376                                          strcat( result, strL);              strcat( result, "W=" );
377                                          strcat( result, "~");              strcat( result, strW );
378                                          strcat( result, strT);              strcat( result, "." );
379                                          strcat( result, "~");              
380                                          strcat( result, strR);              buffer = result;
381                                          strcat( result, "~");              
382                                          strcat( result, strB);              break;
383                                          strcat( result, ";" );              
384                case HSHELL_WINDOWDESTROYED:
385                                          buffer = result;              
386                //get window id
387                                          break;              windowHandle = ( HWND ) wParam;
388                itoa( ( int ) windowHandle, strWindowId, 10 );
389                                  case HSHELL_WINDOWDESTROYED:              
390                                                //get coords
391                                          //get window id              GetWindowRect( windowHandle, &rect );
392                                          windowHandle = (HWND) wParam;              b = rect.bottom;
393                                          itoa((int)windowHandle, strWindowId, 10);              t = rect.top;
394                                                        l = rect.left;
395                                          //get name              r = rect.right;
396                                          GetWindowText(windowHandle,windowTitle,150);              ltoa( b - t, strH, 10 );
397                ltoa( t, strY, 10 );
398                                          ////setup return string              ltoa( r - l, strW, 10 );
399                                          strcat(result, "MSG=HSHELL_WINDOWDESTROYED;");              ltoa( l, strX, 10 );
400                                          strcat( result, "ID=" );              
401                                          strcat( result, strWindowId );              //get name
402                                          strcat( result, ";" );              GetWindowText( windowHandle, windowTitle, 150 );
403                                          strcat( result, "TITLE=" );              
404                                          strcat( result, windowTitle);              ////setup return string
405                                          strcat( result, ";" );              strcat( result, "MSG=HSHELL_WINDOWDESTROYED;OP=1;" );
406                strcat( result, "ID=" );
407                                          buffer = result;              strcat( result, strWindowId );
408                strcat( result, ";" );
409                                          break;              strcat( result, "TITLE=" );
410                                  default:              strcat( result, windowTitle );
411                                          break;              strcat( result, ";" );
412                          }              strcat( result, "X=" );
413                strcat( result, strX );
414                  if ( buffer != NULL)              strcat( result, ";" );
415                  {              strcat( result, "Y=" );
416                          WriteToChannel(buffer);              strcat( result, strY );
417                  }              strcat( result, ";" );
418          }              strcat( result, "H=" );
419                        strcat( result, strH );
420          return CallNextHookEx(hhook, nCode, wParam, lParam);              strcat( result, ";" );
421  }              strcat( result, "W=" );
422                strcat( result, strW );
423  DLL_EXPORT void SetCbtHook(void)              strcat( result, "." );
424  {              
425          if (!bHooked)              buffer = result;
426          {              
427                  hhook           = SetWindowsHookEx(WH_CBT, (HOOKPROC)CbtProc, hInst, (DWORD)NULL);              break;
428                  bHooked         = true;              default:
429          }              break;
430            }
431          if (!bHooked2)          
432          {          if ( buffer != NULL ) {
433                  hhook2          = SetWindowsHookEx(WH_SHELL, (HOOKPROC)ShellProc, hInst, (DWORD)NULL);                WriteToChannel( buffer );
434                  bHooked2                = true;          }
435          }      }
436        
437          if (!bHooked3)      return CallNextHookEx( hhook, nCode, wParam, lParam );
438          {  }
439                  hhook3          = SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)CallWndProc, hInst, (DWORD)NULL);    
440                  bHooked3                = true;  DLL_EXPORT void SetCbtHook( void )
441          }  {
442  }      if ( !bHooked ) {
443            hhook = SetWindowsHookEx( WH_CBT, ( HOOKPROC ) CbtProc, hInst, ( DWORD ) NULL );
444  DLL_EXPORT      void RemoveCbtHook(void)          bHooked = true;
445  {      }
446          if(bHooked)      
447          {      if ( !bHooked2 ) {
448                  UnhookWindowsHookEx(hhook);              hhook2 = SetWindowsHookEx( WH_SHELL, ( HOOKPROC ) ShellProc, hInst, ( DWORD ) NULL );
449                  bHooked = false;          bHooked2 = true;
450          }      }
451        
452          if(bHooked2)      if ( !bHooked3 ) {
453          {          hhook3 = SetWindowsHookEx( WH_CALLWNDPROC, ( HOOKPROC ) CallWndProc, hInst, ( DWORD ) NULL );
454                  UnhookWindowsHookEx(hhook2);              bHooked3 = true;
455                  bHooked2 = false;      }
456          }  }
457    
458          if(bHooked3)  DLL_EXPORT void RemoveCbtHook( void )
459          {  {
460                  UnhookWindowsHookEx(hhook3);          if ( bHooked ) {
461                  bHooked3 = false;          UnhookWindowsHookEx( hhook );
462          }          bHooked = false;
463  }      }
464        
465  DLL_EXPORT int GetInstanceCount()      if ( bHooked2 ) {
466  {          UnhookWindowsHookEx( hhook2 );
467          return iInstanceCount;          bHooked2 = false;
468  }      }
469        
470  int OpenVirtualChannel()      if ( bHooked3 ) {
471  {          UnhookWindowsHookEx( hhook3 );
472                  m_vcHandle = WTSVirtualChannelOpen(WTS_CURRENT_SERVER_HANDLE,WTS_CURRENT_SESSION,CHANNELNAME);          bHooked3 = false;
473                        }
474                  if (m_vcHandle==NULL)  }
475                  {  
476                          return 0;  DLL_EXPORT int GetInstanceCount()
477                  }  {
478                  else      return iInstanceCount;
479                  {  }
480                          return 1;  
481                  }  int OpenVirtualChannel()
482  }  {
483        m_vcHandle = WTSVirtualChannelOpen( WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, CHANNELNAME );
484  int CloseVirtualChannel()      
485  {      if ( m_vcHandle == NULL ) {
486          BOOL result = WTSVirtualChannelClose(m_vcHandle);          return 0;
487          } else {
488           m_vcHandle = NULL;          return 1;
489                }
490          if (result)  }
491          {  
492                  return 1;  int CloseVirtualChannel()
493          }  {
494          else      BOOL result = WTSVirtualChannelClose( m_vcHandle );
495          {      
496                  return 0;      m_vcHandle = NULL;
497          }      
498  }      if ( result ) {
499            return 1;
500  int ChannelIsOpen()      } else {
501  {          return 0;
502          if (m_vcHandle==NULL)      }
503          {  }
504                  return 0;  
505          }  int ChannelIsOpen()
506          else  {
507          {      if ( m_vcHandle == NULL ) {
508                  return 1;          return 0;
509          }      } else {
510  }          return 1;
511        }
512  int WriteToChannel(PCHAR buffer)  }
513  {  
514      PULONG bytesRead      = 0;  int WriteToChannel( PCHAR buffer )
515          PULONG pBytesWritten  = 0;  {
516        PULONG bytesRead = 0;
517          BOOL result = WTSVirtualChannelWrite(m_vcHandle,buffer,(ULONG) strlen(buffer),pBytesWritten);      PULONG pBytesWritten = 0;
518                
519          if (result)      BOOL result = WTSVirtualChannelWrite( m_vcHandle, buffer, ( ULONG ) strlen( buffer ), pBytesWritten );
520          {      
521                  return 1;      if ( result ) {
522          }          return 1;
523          else      } else {
524          {          return 0;
525                  return 0;      }
526          }  }
 }  
Legend:
Removed from v.918  
changed lines
  Added in v.999
  ViewVC Help
Powered by ViewVC 1.1.26