DMARC: expand main-config options. Bug 3102
[exim.git] / src / exim_monitor / em_main.c
1 /*************************************************
2 *                  Exim Monitor                  *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2021 - 2023 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10
11 #include "em_hdr.h"
12
13 /* This module contains the main program of the Exim monitor, which
14 sets up the world and then lets the XtAppMainLoop function
15 run things off X events. */
16
17
18 /*************************************************
19 *               Static variables                 *
20 *************************************************/
21
22 /* Fallback resources */
23
24 static String fallback_resources[] = {"eximon.geometry: +150+0", NULL};
25
26 /* X11 fixed argument lists */
27
28 static Arg quit_args[] = {
29   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
30   {XtNlabel,    (XtArgVal) " Quit "},
31   {"left",      XawChainLeft},
32   {"right",     XawChainLeft},
33   {"top",       XawChainTop},
34   {"bottom",    XawChainTop}
35 };
36
37 static Arg resize_args[] = {
38   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
39   {XtNfromHoriz,(XtArgVal) NULL},         /* must be second */
40   {XtNlabel,    (XtArgVal) " Size "},
41   {"left",      XawChainLeft},
42   {"right",     XawChainLeft},
43   {"top",       XawChainTop},
44   {"bottom",    XawChainTop}
45 };
46
47 static Arg update_args[] = {
48   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
49   {XtNlabel,    (XtArgVal) " Update "},
50   {"left",      XawChainLeft},
51   {"right",     XawChainLeft},
52   {"top",       XawChainTop},
53   {"bottom",    XawChainTop}
54 };
55
56 static Arg hide_args[] = {
57   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
58   {XtNfromHoriz,(XtArgVal) NULL},         /* must be second */
59   {XtNlabel,    (XtArgVal) " Hide "},
60   {"left",      XawChainLeft},
61   {"right",     XawChainLeft},
62   {"top",       XawChainTop},
63   {"bottom",    XawChainTop}
64 };
65
66 static Arg unhide_args[] = {
67   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
68   {XtNfromHoriz,(XtArgVal) NULL},         /* must be second */
69   {XtNlabel,    (XtArgVal) " Unhide "},
70   {"left",      XawChainLeft},
71   {"right",     XawChainLeft},
72   {"top",       XawChainTop},
73   {"bottom",    XawChainTop}
74 };
75
76 static Arg log_args[] = {
77   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
78   {"editType",  XawtextEdit},
79   {"useStringInPlace", (XtArgVal)TRUE},
80   {"string",    (XtArgVal)""},            /* dummy to get it going */
81   {"scrollVertical", XawtextScrollAlways},
82   {"scrollHorizontal", XawtextScrollAlways},
83   {"right",     XawChainRight},
84   {"top",       XawChainTop},
85   {"bottom",    XawChainTop}
86 };
87
88 static Arg queue_args[] = {
89   {XtNfromVert, (XtArgVal) NULL},         /* must be first */
90   {"editType",  XawtextEdit},
91   {"string",    (XtArgVal)""},            /* dummy to get it going */
92   {"scrollVertical", XawtextScrollAlways},
93   {"right",     XawChainRight},
94   {"top",       XawChainTop},
95   {"bottom",    XawChainBottom}
96 };
97
98 static Arg sizepos_args[] = {
99   {"width",     (XtArgVal)NULL},
100   {"height",    (XtArgVal)NULL},
101   {"x",         (XtArgVal)NULL},
102   {"y",         (XtArgVal)NULL}
103 };
104
105 XtActionsRec menu_action_table[] = {
106   { "menu-create",  menu_create } };
107
108 /* Types of non-message dialog action */
109
110 enum { da_hide };
111
112 /* Miscellaneous local variables */
113
114 static int dialog_action;
115 static int tick_stripchart_accumulator = 999999;
116 static int tick_interval = 2;
117 static int maxposset = 0;
118 static int minposset = 0;
119 static int x_adjustment = -1;
120 static int y_adjustment = -1;
121 static Dimension screenwidth, screenheight;
122 static Dimension original_x, original_y;
123 static Dimension maxposx, maxposy;
124 static Dimension minposx, minposy;
125 static Dimension maxwidth, maxheight;
126 static Widget outer_form_widget;
127 static Widget hide_widget;
128 static Widget above_queue_widget;
129
130
131
132
133 #ifdef STRERROR_FROM_ERRLIST
134 /*************************************************
135 *     Provide strerror() for non-ANSI libraries  *
136 *************************************************/
137
138 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
139 in their libraries, but can provide the same facility by this simple
140 alternative function. */
141
142 uschar *
143 strerror(int n)
144 {
145 if (n < 0 || n >= sys_nerr) return "unknown error number";
146 return sys_errlist[n];
147 }
148 #endif /* STRERROR_FROM_ERRLIST */
149
150
151
152 /*************************************************
153 *         Handle attempts to write the log       *
154 *************************************************/
155
156 /* The message gets written to stderr when log_write() is called from a
157 utility. The message always gets '\n' added on the end of it. These calls come
158 from modules such as store.c when things go drastically wrong (e.g. malloc()
159 failing). In normal use they won't get obeyed.
160
161 Arguments:
162   selector  not relevant when running a utility
163   flags     not relevant when running a utility
164   format    a printf() format
165   ...       arguments for format
166
167 Returns:    nothing
168 */
169
170 void
171 log_write(unsigned int selector, int flags, const char *format, ...)
172 {
173 va_list ap;
174 va_start(ap, format);
175 vfprintf(stderr, format, ap);
176 fprintf(stderr, "\n");
177 va_end(ap);
178 }
179
180
181
182
183 /*************************************************
184 *                SIGCHLD handler                 *
185 *************************************************/
186
187 /* Operations on messages are done in subprocesses; this handler
188 just catches them when they finish. It causes a queue display update
189 unless configured not to. */
190
191 static void sigchld_handler(int sig)
192 {
193 while (waitpid(-1, NULL, WNOHANG) > 0);
194 signal(sig, sigchld_handler);
195 if (action_queue_update) tick_queue_accumulator = 999999;
196 }
197
198
199
200 /*************************************************
201 *             Callback routines                  *
202 *************************************************/
203
204
205 void updateAction(Widget w, XtPointer client_data, XtPointer call_data)
206 {
207 scan_spool_input(TRUE);
208 queue_display();
209 tick_queue_accumulator = 0;
210 }
211
212 void hideAction(Widget w, XtPointer client_data, XtPointer call_data)
213 {
214 actioned_message[0] = 0;
215 dialog_ref_widget = w;
216 dialog_action = da_hide;
217 create_dialog(US"Hide addresses ending with", US"");
218 }
219
220 void unhideAction(Widget w, XtPointer client_data, XtPointer call_data)
221 {
222 skip_item *sk = queue_skip;
223
224 while (sk)
225   {
226   skip_item *next = sk->next;
227   store_free(sk);
228   sk = next;
229   }
230 queue_skip = NULL;
231
232 XtDestroyWidget(unhide_widget);
233 unhide_widget = NULL;
234
235 scan_spool_input(TRUE);
236 queue_display();
237 tick_queue_accumulator = 0;
238 }
239
240 void quitAction(Widget w, XtPointer client_data, XtPointer call_data)
241 {
242 exit(0);
243 }
244
245
246 /* Action when the "Size" button is pressed. This is a kludged up mess
247 that I made work after much messing around. Reading the position of the
248 toplevel widget gets the absolute position of the data portion of the window,
249 excluding the window manager's furniture. However, positioning the toplevel
250 widget's window seems to position the top corner of the furniture under the twm
251 window manager, but not under fwvm and others. The two cases are distinguished
252 by the values of x_adjustment and y_adjustment.
253
254 For twm (adjustment >= 0), one has to fudge the miminizing function to ensure
255 that we go back to exactly the same position as before.
256
257 For fwvm (adjustment < 0), one has to fudge the "top left hand corner"
258 positioning to ensure that the window manager's furniture gets displayed on the
259 screen. I haven't found a way of discovering the thickness of the furniture, so
260 some screwed-in values are used.
261
262 This is all ad hoc, developed by floundering around as I haven't found any
263 documentation that tells me what I really should do. */
264
265 void resizeAction(Widget button, XtPointer client_data, XtPointer call_data)
266 {
267 Dimension x, y;
268 Dimension width, height;
269 XWindowAttributes a;
270 Window w = XtWindow(toplevel_widget);
271
272 /* Get the position and size of the top level widget. */
273
274 sizepos_args[0].value = (XtArgVal)(&width);
275 sizepos_args[1].value = (XtArgVal)(&height);
276 sizepos_args[2].value = (XtArgVal)(&x);
277 sizepos_args[3].value = (XtArgVal)(&y);
278 XtGetValues(toplevel_widget, sizepos_args, 4);
279
280 /* Get the position of the widget's window relative to its parent; this
281 gives the thickness of the window manager's furniture. At least it does
282 in twm. For fwvm it gives zero. The size/movement function uses this data.
283 I tried doing this before entering the main loop, but it didn't always
284 work properly with twm. Running it every time seems to be OK. */
285
286 XGetWindowAttributes(X_display, XtWindow(toplevel_widget), &a);
287 if (a.x != 0) x_adjustment = a.x;
288 if (a.y != 0) y_adjustment = a.y;
289
290 /* If at maximum size, reduce to minimum and move back to where it was
291 when maximized, if that value is set, allowing for the furniture in cases
292 where the positioning includes the furniture. */
293
294 if (width == maxwidth && height == maxheight)
295   {
296   maxposx = x;
297   maxposy = y;
298   maxposset = 1;
299
300   if (minposset)
301     xs_SetValues(toplevel_widget, 4,
302       "width",     min_width,
303       "height",    min_height,
304       "x",         minposx - ((x_adjustment >= 0)? x_adjustment : 0),
305       "y",         minposy - ((y_adjustment >= 0)? y_adjustment : 0));
306   else
307     xs_SetValues(toplevel_widget, 2,
308       "width",     min_width,
309       "height",    min_height);
310   }
311
312 /* Else always expand to maximum. If currently at minimum size, remember where
313 it was for coming back. If we don't have a value for the thickness of the
314 furniture, the implication is that the coordinates position the application
315 window, so we can't use (0,0) because that loses the furniture. Use screwed in
316 values that seem to work with fvwm. */
317
318 else
319   {
320   int xx = x;
321   int yy = y;
322
323   if (width == min_width && height == min_height)
324     {
325     minposx = x;
326     minposy = y;
327     minposset = 1;
328     }
329
330   if ((int)(x + maxwidth) > (int)screenwidth ||
331       (int)(y + maxheight + 10) > (int)screenheight)
332     {
333     if (maxposset)
334       {
335       xx = maxposx - ((x_adjustment >= 0)? x_adjustment : 0);
336       yy = maxposy - ((y_adjustment >= 0)? y_adjustment : 0);
337       }
338     else
339       {
340       if ((int)(x + maxwidth) > (int)screenwidth)
341         xx = (x_adjustment >= 0)? 0 : 4;
342       if ((int)(y + maxheight + 10) > (int)screenheight)
343         yy = (y_adjustment >= 0)? 0 : 21;
344       }
345
346     xs_SetValues(toplevel_widget, 4,
347       "width",     maxwidth,
348       "height",    maxheight,
349       "x",         xx,
350       "y",         yy);
351     }
352
353   else xs_SetValues(toplevel_widget, 2,
354         "width",     maxwidth,
355         "height",    maxheight);
356   }
357
358 /* Ensure the window is at the top */
359
360 XRaiseWindow(X_display, w);
361 }
362
363
364
365
366 /*************************************************
367 *          Handle input from non-msg dialogue    *
368 *************************************************/
369
370 /* The various cases here are: hide domain, (no more yet) */
371
372 void NonMessageDialogue(uschar *s)
373 {
374 skip_item *sk;
375
376 switch(dialog_action)
377   {
378   case da_hide:
379
380   /* Create the unhide button if not present */
381
382   if (unhide_widget == NULL)
383     {
384     unhide_args[0].value = (XtArgVal) above_queue_widget;
385     unhide_args[1].value = (XtArgVal) hide_widget;
386     unhide_widget = XtCreateManagedWidget("unhide", commandWidgetClass,
387       outer_form_widget, unhide_args, XtNumber(unhide_args));
388     XtAddCallback(unhide_widget, "callback",  unhideAction, NULL);
389     }
390
391   /* Add item to skip queue */
392
393   sk = (skip_item *)store_malloc(sizeof(skip_item) + Ustrlen(s));
394   sk->next = queue_skip;
395   queue_skip = sk;
396   Ustrcpy(sk->text, s);
397   sk->reveal = time(NULL) + 60 * 60;
398   scan_spool_input(TRUE);
399   queue_display();
400   tick_queue_accumulator = 0;
401   break;
402   }
403 }
404
405
406
407 /*************************************************
408 *              Ticker function                   *
409 *************************************************/
410
411 /* This function is called initially to set up the starting data
412 values; it then sets a timeout so that it continues to be called
413 every 2 seconds. */
414
415 static void ticker(XtPointer pt, XtIntervalId *i)
416 {
417 pipe_item **pp = &pipe_chain;
418 pipe_item *p = pipe_chain;
419 tick_queue_accumulator += tick_interval;
420 tick_stripchart_accumulator += tick_interval;
421 read_log();
422
423 /* If we have passed the queue update time, we must do a full
424 scan of the queue, checking for new arrivals, etc. This will
425 as a by-product set the count of items for use by the stripchart
426 display. On some systems, SIGCHLD signals can get lost at busy times,
427 so just in case, clean up any completed children here. */
428
429 if (tick_queue_accumulator >= queue_update)
430   {
431   scan_spool_input(TRUE);
432   queue_display();
433   tick_queue_accumulator = 0;
434   if (tick_stripchart_accumulator >= stripchart_update)
435     tick_stripchart_accumulator = 0;
436   while (waitpid(-1, NULL, WNOHANG) > 0);
437   }
438
439 /* Otherwise, if we have exceeded the stripchart interval,
440 do a reduced queue scan that simply provides the count for
441 the stripchart. */
442
443 else if (tick_stripchart_accumulator >= stripchart_update)
444   {
445   scan_spool_input(FALSE);
446   tick_stripchart_accumulator = 0;
447   }
448
449 /* Scan any pipes that are set up for listening to delivery processes,
450 and display their output if their windows are still open. */
451
452 while (p != NULL)
453   {
454   int count;
455   uschar buffer[256];
456
457   while ((count = read(p->fd, buffer, 254)) > 0)
458     {
459     buffer[count] = 0;
460     if (p->widget != NULL) text_show(p->widget, buffer);
461     }
462
463   if (count == 0)
464     {
465     close(p->fd);
466     *pp = p->next;
467     store_free(p);
468     /* If configured, cause display update */
469     if (action_queue_update) tick_queue_accumulator = 999999;
470     }
471
472   else pp = &(p->next);
473
474   p = *pp;
475   }
476
477 /* Reset the timer for next time */
478
479 XtAppAddTimeOut(X_appcon, tick_interval * 1000, ticker, 0);
480 }
481
482
483
484 /*************************************************
485 *             Find Num Lock modifiers            *
486 *************************************************/
487
488 /* Return a string with the modifiers generated by XK_Num_Lock, or return
489 NULL if XK_Num_Lock doesn't generate any modifiers. This is needed because Num
490 Lock isn't always the same modifier on all servers.
491
492 Arguments:
493   display   the Display
494   buf       a buffer in which to put the answers (long enough to hold 5)
495
496 Returns:    points to the buffer, or NULL
497 */
498
499 static uschar *
500 numlock_modifiers(Display *display, uschar *buf)
501 {
502 XModifierKeymap *m;
503 int i, j;
504 uschar *ret = NULL;
505
506 m = XGetModifierMapping(display);
507 if (m == NULL)
508   {
509   printf("Not enough memory\n");
510   exit (EXIT_FAILURE);
511   }
512
513 /* Look at Mod1 through Mod5, and fill in the buffer as necessary. */
514
515 buf[0] = 0;
516 for (i = 3; i < 8; i++)
517   {
518   for (j = 0; j < m->max_keypermod; j++)
519     {
520     if (XKeycodeToKeysym(display, m->modifiermap [i*m->max_keypermod + j], 0)
521         == XK_Num_Lock)
522       {
523       sprintf(CS(buf+Ustrlen(buf)), " Mod%d", i-2);
524       ret = buf;
525       }
526     }
527   }
528
529 XFreeModifiermap(m);
530 return ret;
531 }
532
533
534
535 /*************************************************
536 *               Initialize                       *
537 *************************************************/
538
539 int
540 main(int argc, char **argv)
541 {
542 int i;
543 struct stat statdata;
544 uschar modbuf[] = " Mod1 Mod2 Mod3 Mod4 Mod5";
545 uschar *numlock;
546 Widget stripchart_form_widget,
547        update_widget,
548        quit_widget,
549        resize_widget;
550
551 /* The exim global message_id needs to get set */
552
553 message_id_external = message_id_option + 1;
554 message_id = message_id_external + 1;
555 message_subdir[1] = 0;
556
557 /* Some store needs getting for big_buffer, which is used for
558 constructing file names and things. This call will initialize
559 the store_get() function. */
560
561 store_init();
562 big_buffer = store_get(big_buffer_size, GET_UNTAINTED);
563
564 /* Set up the version string and date and output them */
565
566 version_init();
567 printf("\nExim Monitor version %s (compiled %s) initializing\n",
568   version_string, version_date);
569
570 /* Initialize various things from the environment and arguments. */
571
572 init(argc, USS argv);
573
574 /* Set up the SIGCHLD handler */
575
576 signal(SIGCHLD, sigchld_handler);
577
578 /* Get the buffer for storing the string for the log display. */
579
580 log_display_buffer = US store_malloc(log_buffer_size);
581 log_display_buffer[0] = 0;
582
583 /* Initialize the data structures for the stripcharts */
584
585 stripchart_init();
586
587 /* If log_file contains the empty string, then Exim is running using syslog
588 only, and we can't tail the log. If not, open the log file and position to the
589 end of it. Before doing so, we have to detect whether the log files are
590 datestamped, and if so, sort out the name. The string in log_file already has
591 %s replaced by "main"; if datestamping is occurring, %D or %M will be present.
592 In fact, we don't need to test explicitly - just process the string with
593 string_format.
594
595 Once opened, save the file's inode so that we can detect when the file is
596 switched to another one for non-datestamped files. However, allow the monitor
597 to start up without a log file (can happen if no messages have been sent
598 today.) */
599
600 if (log_file[0] != 0)
601   {
602   /* Do *not* use "%s" here, we need the %D datestamp in the log_file to
603   be expanded! */
604   (void)string_format(log_file_open, sizeof(log_file_open), CS log_file, NULL);
605   log_datestamping = string_datestamp_offset >= 0;
606
607   LOG = fopen(CS log_file_open, "r");
608
609   if (LOG == NULL)
610     {
611     printf("*** eximon warning: can't open log file %s - will try "
612       "periodically\n", log_file_open);
613     }
614   else
615     {
616     fseek(LOG, 0, SEEK_END);
617     log_position = ftell(LOG);
618     if (fstat(fileno(LOG), &statdata))
619       {
620       perror("log file fstat");
621       fclose(LOG);
622       LOG=NULL;
623       }
624     else
625       log_inode = statdata.st_ino;
626     }
627   }
628 else
629   {
630   printf("*** eximon warning: no log file available to tail\n");
631   }
632
633 /* Now initialize the X world and create the top-level widget */
634
635 toplevel_widget = XtAppInitialize(&X_appcon, "Eximon", NULL, 0, &argc, argv,
636   fallback_resources, NULL, 0);
637 X_display = XtDisplay(toplevel_widget);
638 xs_SetValues(toplevel_widget, 4,
639   "title",     window_title,
640   "iconName",  window_title,
641   "minWidth",  min_width,
642   "minHeight", min_height);
643
644
645 /* Create the action for setting up the menu in the queue display
646 window, and register the action for positioning the menu. */
647
648 XtAppAddActions(X_appcon, menu_action_table, 1);
649 XawSimpleMenuAddGlobalActions(X_appcon);
650
651 /* Set up translation tables for the text widgets we use. We don't
652 want all the generality of editing, etc. that the defaults provide.
653 This cannot be done before initializing X - the parser complains
654 about unknown events, modifiers, etc. in an unhelpful way... The
655 queue text widget has a different table which includes the button
656 for popping up the menu. Note that the order of things in these
657 tables is significant. Shift<thing> must come before <thing> as
658 otherwise it isn't noticed. */
659
660 /*
661    <FocusIn>:      display-caret(on)\n\
662    <FocusOut>:     display-caret(off)\n\
663 */
664
665 /* The translation manager sets up passive grabs for the menu popups as a
666 result of MenuPopup(), but the grabs match only the exact modifiers listed,
667 hence combinations with and without caps-lock and num-lock must be given,
668 rather than just one "Shift<Btn1Down>" (or whatever menu_event is set to),
669 despite the fact that that notation (without a leading !) should ignore the
670 state of other modifiers. Thanks to Kevin Ryde for this information, and for
671 the function above that discovers which modifier is Num Lock, because it turns
672 out that it varies from server to server. */
673
674 sprintf(CS big_buffer,
675   "!%s:            menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\
676    !Lock %s:       menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\
677   ", menu_event, menu_event);
678
679 numlock = numlock_modifiers(X_display, modbuf); /* Get Num Lock modifier(s) */
680
681 if (numlock != NULL) sprintf(CS big_buffer + Ustrlen(big_buffer),
682   "!%s %s:         menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\
683    !Lock %s %s:    menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\
684   ", numlock, menu_event, numlock, menu_event);
685
686 sprintf(CS big_buffer + Ustrlen(big_buffer),
687   "<Btn1Down>:     select-start()\n\
688    <Btn1Motion>:   extend-adjust()\n\
689    <Btn1Up>:       extend-end(PRIMARY,CUT_BUFFER0)\n\
690    <Btn3Down>:     extend-start()\n\
691    <Btn3Motion>:   extend-adjust()\n\
692    <Btn3Up>:       extend-end(PRIMARY,CUT_BUFFER0)\n\
693    <Key>Up:        scroll-one-line-down()\n\
694    <Key>Down:      scroll-one-line-up()\n\
695    Ctrl<Key>R:     search(backward)\n\
696    Ctrl<Key>S:     search(forward)\n\
697   ");
698
699 queue_trans = XtParseTranslationTable(CS big_buffer);
700
701 text_trans = XtParseTranslationTable(
702   "<Btn1Down>:     select-start()\n\
703    <Btn1Motion>:   extend-adjust()\n\
704    <Btn1Up>:       extend-end(PRIMARY,CUT_BUFFER0)\n\
705    <Btn3Down>:     extend-start()\n\
706    <Btn3Motion>:   extend-adjust()\n\
707    <Btn3Up>:       extend-end(PRIMARY,CUT_BUFFER0)\n\
708    <Key>Up:        scroll-one-line-down()\n\
709    <Key>Down:      scroll-one-line-up()\n\
710    Ctrl<Key>R:     search(backward)\n\
711    Ctrl<Key>S:     search(forward)\n\
712   ");
713
714
715 /* Create a toplevel form widget to hold all the other things */
716
717 outer_form_widget = XtCreateManagedWidget("form", formWidgetClass,
718   toplevel_widget, NULL, 0);
719
720 /* Now create an inner form to hold the stripcharts */
721
722 stripchart_form_widget = XtCreateManagedWidget("form", formWidgetClass,
723   outer_form_widget, NULL, 0);
724 xs_SetValues(stripchart_form_widget, 5,
725   "defaultDistance", 8,
726   "left",            XawChainLeft,
727   "right",           XawChainLeft,
728   "top",             XawChainTop,
729   "bottom",          XawChainTop);
730
731 /* Create the queue count stripchart and its label. */
732
733 create_stripchart(stripchart_form_widget, queue_stripchart_name);
734
735 /* If configured, create the size monitoring stripchart, but
736 only if the OS supports statfs(). */
737
738 if (size_stripchart != NULL)
739   {
740 #ifdef HAVE_STATFS
741   if (size_stripchart_name == NULL)
742     {
743     size_stripchart_name = size_stripchart + Ustrlen(size_stripchart) - 1;
744     while (size_stripchart_name > size_stripchart &&
745       *size_stripchart_name == '/') size_stripchart_name--;
746     while (size_stripchart_name > size_stripchart &&
747       *size_stripchart_name != '/') size_stripchart_name--;
748     }
749   create_stripchart(stripchart_form_widget, size_stripchart_name);
750 #else
751   printf("Can't create size stripchart: statfs() function not available\n");
752 #endif
753   }
754
755 /* Now create the configured input/output stripcharts; note
756 the total number includes the queue stripchart. */
757
758 for (i = stripchart_varstart; i < stripchart_number; i++)
759   create_stripchart(stripchart_form_widget, stripchart_title[i]);
760
761 /* Next in vertical order come the Resize & Quit buttons */
762
763 quit_args[0].value = (XtArgVal) stripchart_form_widget;
764 quit_widget = XtCreateManagedWidget("quit", commandWidgetClass,
765   outer_form_widget, quit_args, XtNumber(quit_args));
766 XtAddCallback(quit_widget, "callback",  quitAction, NULL);
767
768 resize_args[0].value = (XtArgVal) stripchart_form_widget;
769 resize_args[1].value = (XtArgVal) quit_widget;
770 resize_widget = XtCreateManagedWidget("resize", commandWidgetClass,
771   outer_form_widget, resize_args, XtNumber(resize_args));
772 XtAddCallback(resize_widget, "callback",  resizeAction, NULL);
773
774 /* In the absence of log tailing, the quit widget is the one above the
775 queue listing. */
776
777 above_queue_widget = quit_widget;
778
779 /* Create an Ascii text widget for the log tail display if we are tailing a
780 log. Skip it if not. */
781
782 if (log_file[0] != 0)
783   {
784   log_args[0].value = (XtArgVal) quit_widget;
785   log_widget = XtCreateManagedWidget("log", asciiTextWidgetClass,
786     outer_form_widget, log_args, XtNumber(log_args));
787   XawTextDisplayCaret(log_widget, TRUE);
788   xs_SetValues(log_widget, 6,
789     "editType",  XawtextEdit,
790     "translations", text_trans,
791     "string",    log_display_buffer,
792     "length",    log_buffer_size,
793     "height",    log_depth,
794     "width",     log_width);
795
796   if (log_font != NULL)
797     {
798     XFontStruct *f = XLoadQueryFont(X_display, CS log_font);
799     if (f != NULL) xs_SetValues(log_widget, 1, "font", f);
800     }
801
802   above_queue_widget = log_widget;
803   }
804
805 /* The update button */
806
807 update_args[0].value = (XtArgVal) above_queue_widget;
808 update_widget = XtCreateManagedWidget("update", commandWidgetClass,
809   outer_form_widget, update_args, XtNumber(update_args));
810 XtAddCallback(update_widget, "callback",  updateAction, NULL);
811
812 /* The hide button */
813
814 hide_args[0].value = (XtArgVal) above_queue_widget;
815 hide_args[1].value = (XtArgVal) update_widget;
816 hide_widget = XtCreateManagedWidget("hide", commandWidgetClass,
817   outer_form_widget, hide_args, XtNumber(hide_args));
818 XtAddCallback(hide_widget, "callback",  hideAction, NULL);
819
820 /* Create an Ascii text widget for the queue display. */
821
822 queue_args[0].value = (XtArgVal) update_widget;
823 queue_widget = XtCreateManagedWidget("queue", asciiTextWidgetClass,
824   outer_form_widget, queue_args, XtNumber(queue_args));
825 XawTextDisplayCaret(queue_widget, TRUE);
826
827 xs_SetValues(queue_widget, 4,
828   "editType",  XawtextEdit,
829   "height",    queue_depth,
830   "width",     queue_width,
831   "translations", queue_trans);
832
833 if (queue_font != NULL)
834   {
835   XFontStruct *f = XLoadQueryFont(X_display, CS queue_font);
836   if (f != NULL) xs_SetValues(queue_widget, 1, "font", f);
837   }
838
839 /* Call the ticker function to get the initial data set up. It
840 arranges to have itself recalled every 2 seconds. */
841
842 ticker(NULL, NULL);
843
844 /* Everything is now set up; this flag is used by the regerror
845 function and also by the queue reader. */
846
847 eximon_initialized = TRUE;
848 printf("\nExim Monitor running\n");
849
850 /* Realize the toplevel and thereby get things displayed */
851
852 XtRealizeWidget(toplevel_widget);
853
854 /* Find out the size of the initial window, and set that as its
855 maximum. While we are at it, get the initial position. */
856
857 sizepos_args[0].value = (XtArgVal)(&maxwidth);
858 sizepos_args[1].value = (XtArgVal)(&maxheight);
859 sizepos_args[2].value = (XtArgVal)(&original_x);
860 sizepos_args[3].value = (XtArgVal)(&original_y);
861 XtGetValues(toplevel_widget, sizepos_args, 4);
862
863 xs_SetValues(toplevel_widget, 2,
864   "maxWidth",  maxwidth,
865   "maxHeight", maxheight);
866
867 /* Set up the size of the screen */
868
869 screenwidth = XDisplayWidth(X_display, 0);
870 screenheight= XDisplayHeight(X_display,0);
871
872 /* Register the action table */
873
874 XtAppAddActions(X_appcon, actionTable, actionTableSize);
875
876 /* Reduce the window to the small size if this is wanted */
877
878 if (start_small) resizeAction(NULL, NULL, NULL);
879
880 /* Enter the application loop which handles things from here
881 onwards. The return statement is never obeyed, but is needed to
882 keep pedantic ANSI compilers happy. */
883
884 XtAppMainLoop(X_appcon);
885
886 return 0;
887 }
888
889 /* End of em_main.c */
890