Add pcre2 support
[privoxy.git] / w32log.c
1 /*********************************************************************
2  *
3  * File        :  $Source: /cvsroot/ijbswa/current/w32log.c,v $
4  *
5  * Purpose     :  Functions for creating and destroying the log window,
6  *                outputting strings, processing messages and so on.
7  *
8  * Copyright   :  Written by and Copyright (C) 2001-2009 members of
9  *                the Privoxy team.  https://www.privoxy.org/
10  *
11  *                Written by and Copyright (C) 1999 Adam Lock
12  *                <locka@iol.ie>
13  *
14  *                This program is free software; you can redistribute it
15  *                and/or modify it under the terms of the GNU General
16  *                Public License as published by the Free Software
17  *                Foundation; either version 2 of the License, or (at
18  *                your option) any later version.
19  *
20  *                This program is distributed in the hope that it will
21  *                be useful, but WITHOUT ANY WARRANTY; without even the
22  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
23  *                PARTICULAR PURPOSE.  See the GNU General Public
24  *                License for more details.
25  *
26  *                The GNU General Public License should be included with
27  *                this file.  If not, you can view it at
28  *                http://www.gnu.org/copyleft/gpl.html
29  *                or write to the Free Software Foundation, Inc., 59
30  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
31  *
32  *********************************************************************/
33
34
35 #include "config.h"
36
37 #include <assert.h>
38 #include <stdio.h>
39
40 #ifndef STRICT
41 #define STRICT
42 #endif
43 #include <winsock2.h>
44 #include <windows.h>
45 #include <richedit.h>
46
47 #include "project.h"
48 #include "w32log.h"
49 #include "w32taskbar.h"
50 #include "win32.h"
51 #include "w32res.h"
52 #include "jcc.h"
53 #include "miscutil.h"
54 #include "errlog.h"
55 #include "loadcfg.h"
56
57 #ifndef _WIN_CONSOLE /* entire file */
58
59 /*
60  * Timers and the various durations
61  */
62 #define TIMER_ANIM_ID               1
63 #define TIMER_ANIM_TIME             100
64 #define TIMER_ANIMSTOP_ID           2
65 #define TIMER_ANIMSTOP_TIME         1000
66 #define TIMER_CLIPBUFFER_ID         3
67 #define TIMER_CLIPBUFFER_TIME       1000
68 #define TIMER_CLIPBUFFER_FORCE_ID   4
69 #define TIMER_CLIPBUFFER_FORCE_TIME 5000
70
71 /*
72  * Styles of text that can be output
73  */
74 #define STYLE_NONE      0
75 #define STYLE_HIGHLIGHT 1
76 #define STYLE_LINK      2
77 #define STYLE_HEADER    3
78
79 /*
80  * Number of frames of animation in tray activity sequence
81  */
82 #define ANIM_FRAMES 8
83
84 #define DEFAULT_MAX_BUFFER_LINES    200
85 #define DEFAULT_LOG_FONT_NAME       "MS Sans Serif"
86 #define DEFAULT_LOG_FONT_SIZE       8
87
88 /*
89  * These values affect the way the log window behaves, they should be read
90  * from a file but for the moment, they are hardcoded here. Some options are
91  * configurable through the UI.
92  */
93
94 /* Indicates whether task bar shows activity animation */
95 BOOL g_bShowActivityAnimation = 1;
96
97 /* Indicates whether the log window is shown */
98 BOOL g_bShowLogWindow = 1;
99
100 /* Indicates if the log window appears on the task bar */
101 BOOL g_bShowOnTaskBar = 0;
102
103 /* Indicates whether closing the log window really just hides it */
104 BOOL g_bCloseHidesWindow = 1;
105
106 /* Indicates if messages are logged at all */
107 BOOL g_bLogMessages = 1;
108
109 /* Indicates whether log messages are highlighted */
110 BOOL g_bHighlightMessages = 1;
111
112 /* Indicates if buffer is limited in size */
113 BOOL g_bLimitBufferSize = 1;
114
115 /* Maximum number of lines allowed in buffer when limited */
116 int g_nMaxBufferLines = DEFAULT_MAX_BUFFER_LINES;
117
118 /* Font to use */
119 char g_szFontFaceName[32] = DEFAULT_LOG_FONT_NAME;
120
121 /* Size of font to use */
122 int g_nFontSize = DEFAULT_LOG_FONT_SIZE;
123
124
125 /* FIXME: this is a kludge */
126
127 const char * g_default_actions_file = NULL;
128 const char * g_user_actions_file = NULL;
129 const char * g_default_filterfile = NULL;
130 const char * g_user_filterfile = NULL;
131 #ifdef FEATURE_TRUST
132 const char * g_trustfile = NULL;
133 #endif /* def FEATURE_TRUST */
134
135 /* FIXME: end kludge */
136
137 /* Regular expression for detected URLs */
138 #define RE_URL "http:[^ \n\r]*"
139
140 /*
141  * Regular expressions that are used to perform highlight in the log window
142  */
143 static struct _Pattern
144 {
145    const char *str;
146    int style;
147    regex_t buffer;
148 } patterns_to_highlight[] =
149 {
150    /* url headers */
151    { RE_URL,                STYLE_LINK },
152 /* { "[a-zA-Z0-9]+\\.[a-zA-Z0-9]+\\.[a-zA-Z0-9]+\\.[^ \n\r]*", STYLE_LINK }, */
153    /* interesting text to highlight */
154    /*   see jcc.c crunch_reason for the full list */
155    { "Crunch: Blocked:",            STYLE_HIGHLIGHT },
156    { "Crunch: Untrusted",           STYLE_HIGHLIGHT },
157    { "Crunch: Redirected:",         STYLE_HIGHLIGHT },
158    { "Crunch: DNS failure",         STYLE_HIGHLIGHT },
159    { "Crunch: Forwarding failed",   STYLE_HIGHLIGHT },
160    { "Crunch: Connection failure",  STYLE_HIGHLIGHT },
161    { "Crunch: Out of memory",       STYLE_HIGHLIGHT },
162    { "Connect: Found reusable socket",     STYLE_HIGHLIGHT },
163    { "Connect: Reusing server socket",     STYLE_HIGHLIGHT },
164    { "Connect: Created new connection to", STYLE_HIGHLIGHT },
165    { "hung up on us",               STYLE_HIGHLIGHT },
166    { "Info: Loading actions file:", STYLE_HIGHLIGHT },
167    { "Info: Loading filter file:",  STYLE_HIGHLIGHT },
168    { "Info: Now toggled ",          STYLE_HIGHLIGHT },
169    { "Crunching Referer:",          STYLE_HIGHLIGHT },
170    /* what are all the possible error strings?? */
171    { "Error:",                      STYLE_HIGHLIGHT },
172    /* http headers */
173    { "referer:",            STYLE_HEADER },
174    { "proxy-connection:",   STYLE_HEADER },
175    { "proxy-agent:",        STYLE_HEADER },
176    { "user-agent:",         STYLE_HEADER },
177    { "host:",               STYLE_HEADER },
178    { "accept:",             STYLE_HEADER },
179    { "accept-encoding:",    STYLE_HEADER },
180    { "accept-language:",    STYLE_HEADER },
181    { "accept-charset:",     STYLE_HEADER },
182    { "accept-ranges:",      STYLE_HEADER },
183    { "date:",               STYLE_HEADER },
184    { "cache-control:",      STYLE_HEADER },
185    { "cache-last-checked:", STYLE_HEADER },
186    { "connection:",         STYLE_HEADER },
187    { "content-type",        STYLE_HEADER },
188    { "content-length",      STYLE_HEADER },
189    { "cookie",              STYLE_HEADER },
190    { "last-modified:",      STYLE_HEADER },
191    { "pragma:",             STYLE_HEADER },
192    { "server:",             STYLE_HEADER },
193    { "etag:",               STYLE_HEADER },
194    { "expires:",            STYLE_HEADER },
195    { "warning:",            STYLE_HEADER },
196    /* this is the terminator statement - do not delete! */
197    { NULL,                  STYLE_NONE }
198 };
199
200 /*
201  * Public variables
202  */
203 HWND g_hwndLogFrame;
204 HICON g_hiconApp;
205
206 /*
207  * Private variables
208  */
209 static CRITICAL_SECTION g_criticalsection;
210 static HWND g_hwndTray;
211 static HWND g_hwndLogBox;
212 static WNDPROC g_fnLogBox;
213 static HICON g_hiconAnim[ANIM_FRAMES];
214 static HICON g_hiconIdle;
215 static HICON g_hiconOff;
216 static int g_nAnimFrame;
217 static BOOL g_bClipPending = FALSE;
218 static int g_nRichEditVersion = 0;
219
220 /*
221  * Private functions
222  */
223 static HWND CreateLogWindow(HINSTANCE hInstance, int nCmdShow);
224 static HWND CreateHiddenLogOwnerWindow(HINSTANCE hInstance);
225 static LRESULT CALLBACK LogWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
226 static LRESULT CALLBACK LogOwnerWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
227 static LRESULT CALLBACK LogRichEditProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
228 static BOOL InitRichEdit(void);
229 static void LogClipBuffer(void);
230 static void LogCreatePatternMatchingBuffers(void);
231 static void LogDestroyPatternMatchingBuffers(void);
232 static int LogPutStringNoMatch(const char *pszText, int style);
233 static void SetIdleIcon(void);
234
235
236 /*********************************************************************
237  *
238  * Function    :  InitLogWindow
239  *
240  * Description :  Initialise the log window.
241  *
242  * Parameters  :  None
243  *
244  * Returns     :  Always TRUE (there should be error checking on the resources).
245  *
246  *********************************************************************/
247 BOOL InitLogWindow(void)
248 {
249    int i;
250
251    /* Load the icons */
252    g_hiconIdle = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_IDLE));
253    g_hiconOff  = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_OFF));
254    for (i = 0; i < ANIM_FRAMES; i++)
255    {
256       g_hiconAnim[i] = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ANIMATED1 + i));
257    }
258    g_hiconApp = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_MAINICON));
259
260    /* Create the user interface */
261    g_hwndLogFrame = CreateLogWindow(g_hInstance, g_nCmdShow);
262    g_hwndTray = CreateTrayWindow(g_hInstance);
263    TrayAddIcon(g_hwndTray, 1, g_hiconApp, "Privoxy");
264
265    /* Create pattern matching buffers (for highlighting */
266    LogCreatePatternMatchingBuffers();
267
268    /* Create a critical section to protect multi-threaded access to certain things */
269    InitializeCriticalSection(&g_criticalsection);
270
271    return TRUE;
272
273 }
274
275
276 /*********************************************************************
277  *
278  * Function    :  TermLogWindow
279  *
280  * Description :  Cleanup the logwindow.
281  *
282  * Parameters  :  None
283  *
284  * Returns     :  N/A
285  *
286  *********************************************************************/
287 void TermLogWindow(void)
288 {
289    int i;
290
291    LogDestroyPatternMatchingBuffers();
292
293    TrayDeleteIcon(g_hwndTray, 1);
294    DeleteObject(g_hiconApp);
295    DeleteObject(g_hiconIdle);
296    DeleteObject(g_hiconOff);
297    for (i = 0; i < ANIM_FRAMES; i++)
298    {
299       DeleteObject(g_hiconAnim[i]);
300    }
301
302 }
303
304
305 /*********************************************************************
306  *
307  * Function    :  LogCreatePatternMatchingBuffers
308  *
309  * Description :  Compile the pattern matching buffers.
310  *
311  * Parameters  :  None
312  *
313  * Returns     :  N/A
314  *
315  *********************************************************************/
316 void LogCreatePatternMatchingBuffers(void)
317 {
318    int i;
319 #ifdef HAVE_PCRE2
320 #warning The win32 build of Privoxy is expected to crash when compiled with pcre2 support.
321 #endif
322    for (i = 0; patterns_to_highlight[i].str != NULL; i++)
323    {
324       regcomp(&patterns_to_highlight[i].buffer, patterns_to_highlight[i].str, REG_ICASE);
325    }
326 }
327
328
329 /*********************************************************************
330  *
331  * Function    :  LogDestroyPatternMatchingBuffers
332  *
333  * Description :  Free up the pattern matching buffers.
334  *
335  * Parameters  :  None
336  *
337  * Returns     :  N/A
338  *
339  *********************************************************************/
340 void LogDestroyPatternMatchingBuffers(void)
341 {
342    int i;
343    for (i = 0; patterns_to_highlight[i].str != NULL; i++)
344    {
345       regfree(&patterns_to_highlight[i].buffer);
346    }
347 }
348
349
350 /*********************************************************************
351  *
352  * Function    :  LogPutString
353  *
354  * Description :  Inserts text into the logging window.  This is really
355  *                a regexp aware wrapper function to `LogPutStringNoMatch'.
356  *
357  * Parameters  :
358  *          1  :  pszText = pointer to string going to the log window
359  *
360  * Returns     :  1 => success, else the return code from `LogPutStringNoMatch'.
361  *                FIXME: this is backwards to the rest of IJB and to common
362  *                programming practice.  Please use 0 => success instead.
363  *
364  *********************************************************************/
365 int LogPutString(const char *pszText)
366 {
367    int i;
368    int result = 0;
369
370    if (!g_bLogMessages)
371    {
372       return 1;
373    }
374
375    if (pszText == NULL || strlen(pszText) == 0)
376    {
377       return 1;
378    }
379
380    /* Critical section stops multiple threads doing nasty interactions that
381     * foul up the highlighting and output.
382     */
383    EnterCriticalSection(&g_criticalsection);
384
385    if (g_bHighlightMessages)
386    {
387       regmatch_t match;
388
389       /* First things first, regexp scan for various things that we would like highlighted */
390       for (i = 0; patterns_to_highlight[i].str != NULL; i++)
391       {
392          if (regexec(&patterns_to_highlight[i].buffer, pszText, 1, &match, 0) == 0)
393          {
394             char *pszBefore = NULL;
395             char *pszMatch = NULL;
396             char *pszAfter = NULL;
397             int nMatchSize;
398
399             /* Split the string up into pieces representing the strings, before
400                at and after the matching pattern
401              */
402             if (match.rm_so > 0)
403             {
404                pszBefore = (char *)malloc((match.rm_so + 1) * sizeof(char));
405                memset(pszBefore, 0, (match.rm_so + 1) * sizeof(char));
406                strncpy(pszBefore, pszText, match.rm_so);
407             }
408             if (match.rm_eo < (regoff_t)strlen(pszText))
409             {
410                pszAfter = strdup(&pszText[match.rm_eo]);
411             }
412             nMatchSize = match.rm_eo - match.rm_so;
413             pszMatch = (char *)malloc(nMatchSize + 1);
414             strncpy(pszMatch, &pszText[match.rm_so], nMatchSize);
415             pszMatch[nMatchSize] = '\0';
416
417             /* Recursively call LogPutString */
418             if (pszBefore)
419             {
420                LogPutString(pszBefore);
421                free(pszBefore);
422             }
423             if (pszMatch)
424             {
425                LogPutStringNoMatch(pszMatch, patterns_to_highlight[i].style);
426                free(pszMatch);
427             }
428             if (pszAfter)
429             {
430                LogPutString(pszAfter);
431                free(pszAfter);
432             }
433
434             result = 1;
435             goto end;
436          }
437       }
438    }
439
440    result = LogPutStringNoMatch(pszText, STYLE_NONE);
441
442 end:
443    LeaveCriticalSection(&g_criticalsection);
444
445    return result;
446
447 }
448
449
450 /*********************************************************************
451  *
452  * Function    :  LogPutStringNoMatch
453  *
454  * Description :  Puts a string into the logging window.
455  *
456  * Parameters  :
457  *          1  :  pszText = pointer to string going to the log window
458  *          2  :  style = STYLE_NONE, STYLE_HEADER, STYLE_HIGHLIGHT, or STYLE_LINK
459  *
460  * Returns     :  Always 1 => success.
461  *                FIXME: this is backwards to the rest of IJB and to common
462  *                programming practice.  Please use 0 => success instead.
463  *
464  *********************************************************************/
465 int LogPutStringNoMatch(const char *pszText, int style)
466 {
467    CHARRANGE range;
468    CHARFORMAT format;
469    int nTextLength;
470
471    assert(g_hwndLogBox);
472    if (g_hwndLogBox == NULL)
473    {
474       return 1;
475    }
476
477    /* TODO preserve existing selection */
478
479    /* Go to the end of the text */
480    nTextLength = GetWindowTextLength(g_hwndLogBox);
481    range.cpMin = nTextLength;
482    range.cpMax = nTextLength;
483    SendMessage(g_hwndLogBox, EM_EXSETSEL, 0, (LPARAM) &range);
484
485    /* Apply a formatting style */
486    memset(&format, 0, sizeof(format));
487    format.cbSize = sizeof(format);
488    format.dwMask = CFM_BOLD | CFM_UNDERLINE | CFM_STRIKEOUT |
489       CFM_ITALIC | CFM_COLOR | CFM_FACE | CFM_SIZE | CFM_CHARSET;
490    format.bCharSet = DEFAULT_CHARSET;
491    format.yHeight = (g_nFontSize * 1440) / 72;
492    strlcpy(format.szFaceName, g_szFontFaceName, sizeof(format.szFaceName));
493    if (style == STYLE_NONE)
494    {
495       /* DO NOTHING */
496       format.dwEffects |= CFE_AUTOCOLOR;
497    }
498    else if (style == STYLE_HEADER)
499    {
500       format.dwEffects |= CFE_AUTOCOLOR | CFE_ITALIC;
501    }
502    else if (style == STYLE_HIGHLIGHT)
503    {
504       format.dwEffects |= CFE_AUTOCOLOR | CFE_BOLD;
505    }
506    else if (style == STYLE_LINK)
507    {
508       format.dwEffects |= CFE_UNDERLINE;
509       format.crTextColor = RGB(0, 0, 255);
510    }
511    SendMessage(g_hwndLogBox, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM) &format);
512
513    /* Append text to the end */
514    SendMessage(g_hwndLogBox, EM_REPLACESEL, FALSE, (LPARAM) pszText);
515
516    /* TODO Restore the old selection */
517
518    /* Purge buffer */
519    if (strchr(pszText, '\n') != NULL)
520    {
521       SetTimer(g_hwndLogFrame, TIMER_CLIPBUFFER_ID, TIMER_CLIPBUFFER_TIME, NULL);
522       if (!g_bClipPending)
523       {
524          /* Set the force clip timer going. This timer ensures clipping is done
525             intermittently even when there is a sustained burst of logging
526          */
527          SetTimer(g_hwndLogFrame, TIMER_CLIPBUFFER_FORCE_ID, TIMER_CLIPBUFFER_FORCE_TIME, NULL);
528       }
529       g_bClipPending = TRUE;
530    }
531
532    return 1;
533
534 }
535
536
537 /*********************************************************************
538  *
539  * Function    :  LogShowActivity
540  *
541  * Description :  Start the spinner.
542  *
543  * Parameters  :  None
544  *
545  * Returns     :  N/A
546  *
547  *********************************************************************/
548 void LogShowActivity(void)
549 {
550    /* Start some activity timers */
551    if (g_bShowActivityAnimation)
552    {
553       SetTimer(g_hwndLogFrame, TIMER_ANIM_ID, TIMER_ANIM_TIME, NULL);
554       SetTimer(g_hwndLogFrame, TIMER_ANIMSTOP_ID, TIMER_ANIMSTOP_TIME, NULL);
555    }
556
557 }
558
559
560 /*********************************************************************
561  *
562  * Function    :  LogClipBuffer
563  *
564  * Description :  Prunes old lines from the log.
565  *
566  * Parameters  :  None
567  *
568  * Returns     :  N/A
569  *
570  *********************************************************************/
571 void LogClipBuffer(void)
572 {
573    int nLines = SendMessage(g_hwndLogBox, EM_GETLINECOUNT, 0, 0);
574    if (g_bLimitBufferSize && nLines > g_nMaxBufferLines)
575    {
576       /* Compute the range representing the lines to be deleted */
577       LONG nLastLineToDelete = nLines - g_nMaxBufferLines;
578       LONG nLastChar = SendMessage(g_hwndLogBox, EM_LINEINDEX, nLastLineToDelete, 0);
579       CHARRANGE range;
580       range.cpMin = 0;
581       range.cpMax = nLastChar;
582
583       /* TODO get current selection */
584
585       /* TODO adjust and clip old selection against range to be deleted */
586
587       /* Select range and erase it (turning off autoscroll to prevent
588          nasty scrolling) */
589       SendMessage(g_hwndLogBox, EM_SETOPTIONS, ECOOP_XOR, ECO_AUTOVSCROLL);
590       SendMessage(g_hwndLogBox, EM_EXSETSEL, 0, (LPARAM) &range);
591       SendMessage(g_hwndLogBox, EM_REPLACESEL, FALSE, (LPARAM) "");
592       SendMessage(g_hwndLogBox, EM_SETOPTIONS, ECOOP_XOR, ECO_AUTOVSCROLL);
593
594       /* reposition (back to) the end of the log content */
595       range.cpMin = SendMessage (g_hwndLogBox, WM_GETTEXTLENGTH, 0, 0);
596       range.cpMax = -1;
597       SendMessage(g_hwndLogBox, EM_EXSETSEL, 0, (LPARAM) &range);
598
599       /* restore vertical ScrollBar stuff (messed up by AUTOVSCROLL) */
600       SendMessage (g_hwndLogBox, EM_SCROLL, SB_LINEDOWN, 0);
601
602    }
603
604 }
605
606
607 /*********************************************************************
608  *
609  * Function    :  CreateHiddenLogOwnerWindow
610  *
611  * Description :  Creates a hidden owner window that stops the log
612  *                window appearing in the task bar.
613  *
614  * Parameters  :
615  *          1  :  hInstance = application's instance handle
616  *
617  * Returns     :  Handle to newly created window.
618  *
619  *********************************************************************/
620 HWND CreateHiddenLogOwnerWindow(HINSTANCE hInstance)
621 {
622    static const char *szWndName = "PrivoxyLogOwner";
623    WNDCLASS wc;
624    HWND hwnd;
625
626    wc.style          = 0;
627    wc.lpfnWndProc    = LogOwnerWindowProc;
628    wc.cbClsExtra     = 0;
629    wc.cbWndExtra     = 0;
630    wc.hInstance      = hInstance;
631    wc.hIcon          = g_hiconApp;
632    wc.hCursor        = 0;
633    wc.hbrBackground  = 0;
634    wc.lpszMenuName   = 0;
635    wc.lpszClassName  = szWndName;
636
637    RegisterClass(&wc);
638
639    hwnd = CreateWindow(szWndName, szWndName,
640       WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
641       CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
642
643    return hwnd;
644
645 }
646
647
648 /*********************************************************************
649  *
650  * Function    :  LogOwnerWindowProc
651  *
652  * Description :  Dummy procedure that does nothing special.
653  *
654  * Parameters  :
655  *          1  :  hwnd = window handle
656  *          2  :  uMsg = message number
657  *          3  :  wParam = first param for this message
658  *          4  :  lParam = next param for this message
659  *
660  * Returns     :  Same as `DefWindowProc'.
661  *
662  *********************************************************************/
663 LRESULT CALLBACK LogOwnerWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
664 {
665    return DefWindowProc(hwnd, uMsg, wParam, lParam);
666
667 }
668
669
670 /*********************************************************************
671  *
672  * Function    :  CreateLogWindow
673  *
674  * Description :  Create the logging window.
675  *
676  * Parameters  :
677  *          1  :  hInstance = application's instance handle
678  *          2  :  nCmdShow = window show value (MIN, MAX, NORMAL, etc...)
679  *
680  * Returns     :  Handle to newly created window.
681  *
682  *********************************************************************/
683 HWND CreateLogWindow(HINSTANCE hInstance, int nCmdShow)
684 {
685    static const char *szWndName = "PrivoxyLogWindow";
686    static const char *szWndTitle = "Privoxy";
687
688    HWND hwnd = NULL;
689    HWND hwndOwner = (g_bShowOnTaskBar) ? NULL : CreateHiddenLogOwnerWindow(hInstance);
690    RECT rcClient;
691    WNDCLASSEX wc;
692
693    memset(&wc, 0, sizeof(wc));
694    wc.cbSize         = sizeof(wc);
695    wc.style          = CS_DBLCLKS;
696    wc.lpfnWndProc    = LogWindowProc;
697    wc.cbClsExtra     = 0;
698    wc.cbWndExtra     = 0;
699    wc.hInstance      = hInstance;
700    wc.hIcon          = g_hiconApp;
701    wc.hCursor        = 0;
702    wc.hbrBackground  = 0;
703    wc.lpszMenuName   = MAKEINTRESOURCE(IDR_LOGVIEW);
704    wc.lpszClassName  = szWndName;
705    wc.hbrBackground  = GetStockObject(WHITE_BRUSH);
706    RegisterClassEx(&wc);
707
708    hwnd = CreateWindowEx(WS_EX_APPWINDOW, szWndName, szWndTitle,
709       WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
710       CW_USEDEFAULT, hwndOwner, NULL, hInstance, NULL);
711
712    /* Now create a child list box */
713    GetClientRect(hwnd, &rcClient);
714
715    /* Create a rich edit control */
716    InitRichEdit();
717    g_hwndLogBox = CreateWindowEx(0, (g_nRichEditVersion == 0x0100) ? "RichEdit" : RICHEDIT_CLASS, "",
718       ES_AUTOVSCROLL | ES_MULTILINE | ES_READONLY | ES_NOHIDESEL | WS_CHILD | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
719       rcClient.left, rcClient.top, rcClient.right, rcClient.bottom,
720       hwnd, NULL, hInstance, NULL);
721 /* SendMessage(g_hwndLogBox, EM_SETWORDWRAPMODE, 0, 0); */
722
723    /* Subclass the control to catch certain messages */
724    g_fnLogBox = (WNDPROC) GetWindowLongPtr(g_hwndLogBox, GWLP_WNDPROC);
725    SetWindowLongPtr(g_hwndLogBox, GWLP_WNDPROC, (LONG_PTR) LogRichEditProc);
726
727    /* Minimizing looks stupid when the log window is not on the task bar, so hide instead */
728    if (!g_bShowOnTaskBar &&
729          (nCmdShow == SW_SHOWMINIMIZED ||
730           nCmdShow == SW_MINIMIZE ||
731           nCmdShow == SW_SHOWMINNOACTIVE))
732    {
733       g_bShowLogWindow = FALSE;
734       nCmdShow = SW_HIDE;
735    }
736
737    ShowWindow(hwnd, nCmdShow);
738    UpdateWindow(hwnd);
739
740
741    GetClientRect(g_hwndLogFrame, &rcClient);
742    SetWindowPos(g_hwndLogBox, NULL, rcClient.left, rcClient.top, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, SWP_NOZORDER);
743
744    return hwnd;
745
746 }
747
748
749 /*********************************************************************
750  *
751  * Function    :  InitRichEdit
752  *
753  * Description :  Initialise the rich edit control library.
754  *
755  * Parameters  :  None
756  *
757  * Returns     :  TRUE => success, FALSE => failure.
758  *                FIXME: this is backwards to the rest of IJB and to common
759  *                programming practice.  Please use 0 => success instead.
760  *
761  *********************************************************************/
762 BOOL InitRichEdit(void)
763 {
764    static HINSTANCE hInstRichEdit;
765    if (hInstRichEdit == NULL)
766    {
767       g_nRichEditVersion = 0;
768       hInstRichEdit = LoadLibraryA("RICHED20.DLL");
769       if (hInstRichEdit)
770       {
771          g_nRichEditVersion = _RICHEDIT_VER;
772       }
773       else
774       {
775          hInstRichEdit = LoadLibraryA("RICHED32.DLL");
776          if (hInstRichEdit)
777          {
778             g_nRichEditVersion = 0x0100;
779          }
780       }
781    }
782    return (hInstRichEdit != NULL) ? TRUE : FALSE;
783
784 }
785
786
787 /*********************************************************************
788  *
789  * Function    :  ShowLogWindow
790  *
791  * Description :  Shows or hides the log window.  We will also raise the
792  *                window on a show command in case it is buried.
793  *
794  * Parameters  :
795  *          1  :  bShow = TRUE to show, FALSE to mimize/hide
796  *
797  * Returns     :  N/A
798  *
799  *********************************************************************/
800 void ShowLogWindow(BOOL bShow)
801 {
802    if (bShow)
803    {
804       SetForegroundWindow(g_hwndLogFrame);
805       SetWindowPos(g_hwndLogFrame, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE);
806
807    }
808    else if (g_bShowOnTaskBar)
809    {
810       ShowWindow(g_hwndLogFrame, SW_MINIMIZE);
811    }
812    else
813    {
814       ShowWindow(g_hwndLogFrame, SW_HIDE);
815    }
816 }
817
818
819 /*********************************************************************
820  *
821  * Function    :  EditFile
822  *
823  * Description :  Opens the specified setting file for editing.
824  * FIXME: What if the file has no associated application. Check for return values
825 *        from ShellExecute??
826  *
827  * Parameters  :
828  *          1  :  filename = filename from the config (aka config.txt) file.
829  *
830  * Returns     :  N/A
831  *
832  *********************************************************************/
833 void EditFile(const char *filename)
834 {
835    if (filename)
836    {
837       ShellExecute(g_hwndLogFrame, "open", filename, NULL, NULL, SW_SHOWNORMAL);
838    }
839
840 }
841
842
843 /*--------------------------------------------------------------------------*/
844 /* Windows message handlers                                                 */
845 /*--------------------------------------------------------------------------*/
846
847
848 /*********************************************************************
849  *
850  * Function    :  OnLogRButtonUp
851  *
852  * Description :  Handler for WM_RBUTTONUP messages.
853  *
854  * Parameters  :
855  *          1  :  nModifier = wParam from mouse message (unused)
856  *          2  :  x = x coordinate of the mouse event
857  *          3  :  y = y coordinate of the mouse event
858  *
859  * Returns     :  N/A
860  *
861  *********************************************************************/
862 void OnLogRButtonUp(int nModifier, int x, int y)
863 {
864    HMENU hMenu = LoadMenu(g_hInstance, MAKEINTRESOURCE(IDR_POPUP_SELECTION));
865    if (hMenu != NULL)
866    {
867       HMENU hMenuPopup = GetSubMenu(hMenu, 0);
868
869       /* Check if there is a selection */
870       CHARRANGE range;
871       SendMessage(g_hwndLogBox, EM_EXGETSEL, 0, (LPARAM) &range);
872       if (range.cpMin == range.cpMax)
873       {
874          EnableMenuItem(hMenuPopup, ID_EDIT_COPY, MF_BYCOMMAND | MF_GRAYED);
875       }
876       else
877       {
878          EnableMenuItem(hMenuPopup, ID_EDIT_COPY, MF_BYCOMMAND | MF_ENABLED);
879       }
880
881       /* Display the popup */
882       TrackPopupMenu(hMenuPopup, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON, x, y, 0, g_hwndLogFrame, NULL);
883       DestroyMenu(hMenu);
884    }
885
886 }
887
888
889 /*********************************************************************
890  *
891  * Function    :  OnLogCommand
892  *
893  * Description :  Handler for WM_COMMAND messages.
894  *
895  * Parameters  :
896  *          1  :  nCommand = the command portion of the menu selection event
897  *
898  * Returns     :  N/A
899  *
900  *********************************************************************/
901 void OnLogCommand(int nCommand)
902 {
903    switch (nCommand)
904    {
905       case ID_TOGGLE_SHOWWINDOW:
906          g_bShowLogWindow = !g_bShowLogWindow;
907
908          ShowLogWindow(g_bShowLogWindow);
909          break;
910
911       case ID_FILE_EXIT:
912          PostMessage(g_hwndLogFrame, WM_CLOSE, 0, 0);
913          break;
914
915       case ID_EDIT_COPY:
916          SendMessage(g_hwndLogBox, WM_COPY, 0, 0);
917          break;
918
919       case ID_VIEW_CLEARLOG:
920          SendMessage(g_hwndLogBox, WM_SETTEXT, 0, (LPARAM) "");
921          break;
922
923       case ID_VIEW_LOGMESSAGES:
924          g_bLogMessages = !g_bLogMessages;
925          /* SaveLogSettings(); */
926          break;
927
928       case ID_VIEW_MESSAGEHIGHLIGHTING:
929          g_bHighlightMessages = !g_bHighlightMessages;
930          /* SaveLogSettings(); */
931          break;
932
933       case ID_VIEW_LIMITBUFFERSIZE:
934          g_bLimitBufferSize = !g_bLimitBufferSize;
935          /* SaveLogSettings(); */
936          break;
937
938       case ID_VIEW_ACTIVITYANIMATION:
939          g_bShowActivityAnimation = !g_bShowActivityAnimation;
940          /* SaveLogSettings(); */
941          break;
942
943 #ifdef FEATURE_TOGGLE
944       case ID_TOGGLE_ENABLED:
945          global_toggle_state = !global_toggle_state;
946          log_error(LOG_LEVEL_INFO,
947             "Now toggled %s", global_toggle_state ? "ON" : "OFF");
948          /*
949           * Leverage TIMER_ANIMSTOP_ID to set the idle icon through the
950           * "application queue". According to MSDN, 10 milliseconds are
951           * the lowest value possible and seem to be close enough to
952           * "instantly".
953           */
954          SetTimer(g_hwndLogFrame, TIMER_ANIMSTOP_ID, 10, NULL);
955          break;
956 #endif /* def FEATURE_TOGGLE */
957
958       case ID_TOOLS_EDITCONFIG:
959          EditFile(configfile);
960          break;
961
962       case ID_TOOLS_EDITDEFAULTACTIONS:
963          EditFile(g_default_actions_file);
964          break;
965
966       case ID_TOOLS_EDITUSERACTIONS:
967          EditFile(g_user_actions_file);
968          break;
969
970       case ID_TOOLS_EDITDEFAULTFILTERS:
971          EditFile(g_default_filterfile);
972          break;
973
974       case ID_TOOLS_EDITUSERFILTERS:
975          EditFile(g_user_filterfile);
976          break;
977
978 #ifdef FEATURE_TRUST
979       case ID_TOOLS_EDITTRUST:
980          EditFile(g_trustfile);
981          break;
982 #endif /* def FEATURE_TRUST */
983
984       case ID_HELP_GPL:
985          ShellExecute(g_hwndLogFrame, "open", "LICENSE.txt", NULL, NULL, SW_SHOWNORMAL);
986          break;
987
988       case ID_HELP_FAQ:
989          ShellExecute(g_hwndLogFrame, "open", "doc\\faq\\index.html", NULL, NULL, SW_SHOWNORMAL);
990          break;
991
992       case ID_HELP_MANUAL:
993          ShellExecute(g_hwndLogFrame, "open", "doc\\user-manual\\index.html", NULL, NULL, SW_SHOWNORMAL);
994          break;
995
996       case ID_HELP_STATUS:
997          ShellExecute(g_hwndLogFrame, "open", CGI_PREFIX "show-status", NULL, NULL, SW_SHOWNORMAL);
998          break;
999
1000       case ID_HELP_ABOUT:
1001          MessageBox(g_hwndLogFrame, win32_blurb, "About Privoxy", MB_OK);
1002          break;
1003
1004       default:
1005          /* DO NOTHING */
1006          break;
1007    }
1008
1009 }
1010
1011
1012 /*********************************************************************
1013  *
1014  * Function    :  OnLogInitMenu
1015  *
1016  * Description :  Handler for WM_INITMENU messages.  Enable, disable,
1017  *                check, and/or uncheck menu options as apropos.
1018  *
1019  * Parameters  :
1020  *          1  :  hmenu = handle to menu to "make current"
1021  *
1022  * Returns     :  N/A
1023  *
1024  *********************************************************************/
1025 void OnLogInitMenu(HMENU hmenu)
1026 {
1027    /* Only enable editors if there is a file to edit */
1028    EnableMenuItem(hmenu, ID_TOOLS_EDITDEFAULTACTIONS, MF_BYCOMMAND | (g_default_actions_file ? MF_ENABLED : MF_GRAYED));
1029    EnableMenuItem(hmenu, ID_TOOLS_EDITUSERACTIONS, MF_BYCOMMAND | (g_user_actions_file ? MF_ENABLED : MF_GRAYED));
1030    EnableMenuItem(hmenu, ID_TOOLS_EDITDEFAULTFILTERS, MF_BYCOMMAND | (g_default_filterfile ? MF_ENABLED : MF_GRAYED));
1031    EnableMenuItem(hmenu, ID_TOOLS_EDITUSERFILTERS, MF_BYCOMMAND | (g_user_filterfile ? MF_ENABLED : MF_GRAYED));
1032 #ifdef FEATURE_TRUST
1033    EnableMenuItem(hmenu, ID_TOOLS_EDITTRUST, MF_BYCOMMAND | (g_trustfile ? MF_ENABLED : MF_GRAYED));
1034 #endif /* def FEATURE_TRUST */
1035
1036    /* Check/uncheck options */
1037    CheckMenuItem(hmenu, ID_VIEW_LOGMESSAGES, MF_BYCOMMAND | (g_bLogMessages ? MF_CHECKED : MF_UNCHECKED));
1038    CheckMenuItem(hmenu, ID_VIEW_MESSAGEHIGHLIGHTING, MF_BYCOMMAND | (g_bHighlightMessages ? MF_CHECKED : MF_UNCHECKED));
1039    CheckMenuItem(hmenu, ID_VIEW_LIMITBUFFERSIZE, MF_BYCOMMAND | (g_bLimitBufferSize ? MF_CHECKED : MF_UNCHECKED));
1040    CheckMenuItem(hmenu, ID_VIEW_ACTIVITYANIMATION, MF_BYCOMMAND | (g_bShowActivityAnimation ? MF_CHECKED : MF_UNCHECKED));
1041 #ifdef FEATURE_TOGGLE
1042    /* by haroon - menu item for Enable toggle on/off */
1043    CheckMenuItem(hmenu, ID_TOGGLE_ENABLED, MF_BYCOMMAND | (global_toggle_state ? MF_CHECKED : MF_UNCHECKED));
1044 #endif /* def FEATURE_TOGGLE */
1045    CheckMenuItem(hmenu, ID_TOGGLE_SHOWWINDOW, MF_BYCOMMAND | (g_bShowLogWindow ? MF_CHECKED : MF_UNCHECKED));
1046
1047 }
1048
1049
1050 /*********************************************************************
1051  *
1052  * Function    :  OnLogTimer
1053  *
1054  * Description :  Handler for WM_TIMER messages.
1055  *
1056  * Parameters  :
1057  *          1  :  nTimer = timer id (animation start/stop or clip buffer)
1058  *
1059  * Returns     :  N/A
1060  *
1061  *********************************************************************/
1062 void OnLogTimer(int nTimer)
1063 {
1064    switch (nTimer)
1065    {
1066       case TIMER_ANIM_ID:
1067          TraySetIcon(g_hwndTray, 1, g_hiconAnim[g_nAnimFrame++ % ANIM_FRAMES]);
1068          break;
1069
1070       case TIMER_ANIMSTOP_ID:
1071          g_nAnimFrame = 0;
1072          SetIdleIcon();
1073          KillTimer(g_hwndLogFrame, TIMER_ANIM_ID);
1074          KillTimer(g_hwndLogFrame, TIMER_ANIMSTOP_ID);
1075          break;
1076
1077       case TIMER_CLIPBUFFER_ID:
1078       case TIMER_CLIPBUFFER_FORCE_ID:
1079          LogClipBuffer();
1080          g_bClipPending = FALSE;
1081          KillTimer(g_hwndLogFrame, TIMER_CLIPBUFFER_ID);
1082          KillTimer(g_hwndLogFrame, TIMER_CLIPBUFFER_FORCE_ID);
1083          break;
1084
1085       default:
1086          /* DO NOTHING */
1087          break;
1088    }
1089
1090 }
1091
1092
1093 /*********************************************************************
1094  *
1095  * Function    :  SetIdleIcon
1096  *
1097  * Description :  Sets the tray icon to either idle or off
1098  *
1099  * Parameters  :  none
1100  *
1101  * Returns     :  N/A
1102  *
1103  *********************************************************************/
1104 void SetIdleIcon()
1105 {
1106 #ifdef FEATURE_TOGGLE
1107          if (!global_toggle_state)
1108          {
1109             TraySetIcon(g_hwndTray, 1, g_hiconOff);
1110          }
1111          else
1112 #endif /* def FEATURE_TOGGLE */
1113          TraySetIcon(g_hwndTray, 1, g_hiconIdle);
1114 }
1115
1116
1117 /*********************************************************************
1118  *
1119  * Function    :  LogRichEditProc
1120  *
1121  * Description :  Window subclass routine handles some events for the rich edit control.
1122  *
1123  * Parameters  :
1124  *          1  :  hwnd = window handle of the rich edit control
1125  *          2  :  uMsg = message number
1126  *          3  :  wParam = first param for this message
1127  *          4  :  lParam = next param for this message
1128  *
1129  * Returns     :  Appropriate M$ window message handler codes.
1130  *
1131  *********************************************************************/
1132 LRESULT CALLBACK LogRichEditProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1133 {
1134    switch (uMsg)
1135    {
1136       case WM_RBUTTONUP:
1137       {
1138          POINT pt;
1139          pt.x = LOWORD(lParam);
1140          pt.y = HIWORD(lParam);
1141          ClientToScreen(hwnd, &pt);
1142          OnLogRButtonUp(wParam, pt.x, pt.y);
1143          return 0;
1144       }
1145       case WM_CHAR:
1146       {
1147          if ((GetKeyState(VK_CONTROL) != 0) && (wParam == 4)) /* ctrl+d */
1148          {
1149              OnLogCommand(ID_VIEW_CLEARLOG);
1150              return 0;
1151          }
1152       }
1153    }
1154    return CallWindowProc(g_fnLogBox, hwnd, uMsg, wParam, lParam);
1155
1156 }
1157
1158
1159 /*********************************************************************
1160  *
1161  * Function    :  LogWindowProc
1162  *
1163  * Description :  Windows call back routine handles events on the log window.
1164  *
1165  * Parameters  :
1166  *          1  :  hwnd = handle of the logging window
1167  *          2  :  uMsg = message number
1168  *          3  :  wParam = first param for this message
1169  *          4  :  lParam = next param for this message
1170  *
1171  * Returns     :  Appropriate M$ window message handler codes.
1172  *
1173  *********************************************************************/
1174 LRESULT CALLBACK LogWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1175 {
1176    switch (uMsg)
1177    {
1178       case WM_CREATE:
1179          return 0;
1180
1181       case WM_CLOSE:
1182          /* This is the end - my only friend - the end */
1183          DestroyWindow(g_hwndLogBox);
1184          DestroyWindow(g_hwndLogFrame);
1185          return 0;
1186
1187       case WM_DESTROY:
1188          PostQuitMessage(0);
1189          return 0;
1190
1191       case WM_SHOWWINDOW:
1192          g_bShowLogWindow = wParam;
1193       case WM_SIZE:  /* note: implicit-fallthrough */
1194          /* Resize the logging window to fit the new frame */
1195          if (g_hwndLogBox)
1196          {
1197             RECT rc;
1198             GetClientRect(g_hwndLogFrame, &rc);
1199             SetWindowPos(g_hwndLogBox, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER);
1200          }
1201          return 0;
1202
1203       case WM_INITMENU:
1204          OnLogInitMenu((HMENU) wParam);
1205          return 0;
1206
1207       case WM_TIMER:
1208          OnLogTimer(wParam);
1209          return 0;
1210
1211       case WM_COMMAND:
1212          OnLogCommand(LOWORD(wParam));
1213          return 0;
1214
1215       case WM_SYSCOMMAND:
1216          switch (wParam)
1217          {
1218             case SC_CLOSE:
1219                if (g_bCloseHidesWindow)
1220                {
1221                   ShowLogWindow(FALSE);
1222                   return 0;
1223                }
1224                break;
1225             case SC_MINIMIZE:
1226                ShowLogWindow(FALSE);
1227                return 0;
1228          }
1229          break;
1230
1231       case WM_CHAR:
1232          if ((GetKeyState(VK_CONTROL) != 0) && (wParam == 4)) /* ctrl+d */
1233          {
1234              OnLogCommand(ID_VIEW_CLEARLOG);
1235              return 0;
1236          }
1237          break;
1238    }
1239
1240    return DefWindowProc(hwnd, uMsg, wParam, lParam);
1241
1242 }
1243
1244 #endif /* ndef _WIN_CONSOLE - entire file */
1245
1246 /*
1247   Local Variables:
1248   tab-width: 3
1249   end:
1250 */