diff options
Diffstat (limited to '')
| -rw-r--r-- | exim_monitor/EDITME | 179 | ||||
| -rw-r--r-- | exim_monitor/em_StripChart.c | 504 | ||||
| -rw-r--r-- | exim_monitor/em_TextPop.c | 767 | ||||
| -rw-r--r-- | exim_monitor/em_globals.c | 237 | ||||
| -rw-r--r-- | exim_monitor/em_hdr.h | 326 | ||||
| -rw-r--r-- | exim_monitor/em_init.c | 237 | ||||
| -rw-r--r-- | exim_monitor/em_log.c | 411 | ||||
| -rw-r--r-- | exim_monitor/em_main.c | 944 | ||||
| -rw-r--r-- | exim_monitor/em_menu.c | 994 | ||||
| -rw-r--r-- | exim_monitor/em_queue.c | 828 | ||||
| -rw-r--r-- | exim_monitor/em_strip.c | 266 | ||||
| -rw-r--r-- | exim_monitor/em_text.c | 73 | ||||
| -rw-r--r-- | exim_monitor/em_version.c | 65 | ||||
| -rw-r--r-- | exim_monitor/em_xs.c | 45 |
14 files changed, 5876 insertions, 0 deletions
diff --git a/exim_monitor/EDITME b/exim_monitor/EDITME new file mode 100644 index 0000000..a70b7cb --- /dev/null +++ b/exim_monitor/EDITME @@ -0,0 +1,179 @@ +################################################## +# The Exim Monitor # +################################################## + +# This is the template for the Exim monitor's main build-time configuration +# file. It contains settings that are independent of any operating system. It +# should be edited and then saved to a file called Local/eximon.conf before +# running the make command to build the monitor, if any settings are required. +# Local/eximon.conf can be empty if no changes are needed. The examples given +# here (commented out) are the default settings. + +# Any settings made in the configuration file can be overridden at run time +# by setting up an environment variable with the same name as any of these +# options, but preceded by EXIMON_, for example, EXIMON_WINDOW_TITLE. + + +################################################################## +# Set these variables as appropriate for your system # +################################################################## + +# The qualifying name for your domain. The only use made of this is for +# testing that certain addresses are the same when displaying the +# log tail, and for shortening sender addresses in the queue display. + +# QUALIFY_DOMAIN= + +# The default minimum width and height for the whole window are 103 and +# 162 pixels respectively. This is enough to hold the left-most stripchart +# and the quit button. The values can be changed here. + +# MIN_HEIGHT=162 +# MIN_WIDTH=103 + +# If you uncomment the following setting, the window will start up at +# its minimum size, instead of the default maximum. There may be a quick +# flash during the start-up process. Defining it this way allows it to be +# overridden by an environment variable. + +# START_SMALL=${EXIMON_START_SMALL-yes} + +# The title for eximon's main display window. It is possible to have +# host name of the machine you are running on substituted into the +# title string. If you include the string ${fullhostname} then the +# complete name is used. If you include ${hostname} then the full +# host name will have the string contained in the DOMAIN variable +# stripped from its right-hand end before being substituted. Any other +# shell or environment variables may also be included. + +# If you use any substitutions, remember to ensure that the $ and {} +# characters are escaped from the shell, e.g. by using single quotes. + +# WINDOW_TITLE="${hostname} eximon" + +# The domain that you want to be stripped from the machine's full hostname +# when forming the short host name for the eximon window title, as +# described above. + +# DOMAIN= + +# Parameters for the rolling display of the tail of the exim log file. +# The width and depth are measured in pixels; LOG_BUFFER specifies the +# amount of store to set aside for holding the log tail, which is displayed +# in a scrolling window. When this store is full, the earlier 50% of it +# is discarded - this is much more efficient that throwing it away line +# by line. The number given can be followed by the letter K to indicate +# that the value is in kilobytes. A minimum value of 1K is enforced. + +# LOG_DEPTH=300 +# LOG_WIDTH=950 +# LOG_BUFFER=20K + +# The font which is used in the log tail display. This is defined in +# the normal X manner. It must be a "character cell" font, because this +# is required by the text widget. + +# LOG_FONT=-misc-fixed-medium-r-normal-*-14-140-*-*-*-*-iso8859-1 + +# Parameters for the display of message that are on the exim queue. +# The width and depth are measured in pixels. + +# QUEUE_DEPTH=200 +# QUEUE_WIDTH=950 + +# The font which is used in the queue display. + +# QUEUE_FONT=$LOG_FONT + +# When a message has more than one undelivered address, they are listed +# one below the other. A limit can be placed on the number of addresses +# displayed for any one message. If there are more, then "..." is used +# to indicate this. + +# QUEUE_MAX_ADDRESSES=10 + +# The display of the contents of the queue is updated every QUEUE_INTERVAL +# seconds by default (there is a button to request update). + +# QUEUE_INTERVAL=300 + +# The size of the popup text window that is used for looking at the +# contents of messages, etc. + +# TEXT_DEPTH=200 + +# The keystroke/mouse-operation that is used to pop up the menu in the +# queue window is configurable. The default is Shift with the lefthand +# mouse button. The name of an alternative can be specified in the standard +# X way of naming these things. With the default configuration for the monitor, +# individuals can override this by setting the EXIMON_MENU_EVENT environment +# variable. + +# MENU_EVENT='Shift<Btn1Down>' + +# When the menu is used to perform an operation on a message, the result of the +# operation is normally visible in the log window, so Eximon doesn't display +# the output of the generated Exim command. However, you can request that +# this output be shown in a separate window by setting ACTION_OUTPUT to "yes". +# This does not apply to the output generated from attempting to deliver a +# message, which is always shown. + +# ACTION_OUTPUT=no + +# When some action is taken on a message, such as freezing it, or changing +# its recipients, the queue display is normally automatically updated. On +# systems that have very large queues, this can take some time and be dis- +# tracting. If this option is set to "no", the queue display is no longer +# automatically updated after an action is applied to a message. + +# ACTION_QUEUE_UPDATE=yes + +# When the menu item to display a message's body is invoked, the amount +# of data is limited to BODY_MAX bytes. This limit is a safety precaution +# to save the screen scrolling for ever on an enormous message. + +# BODY_MAX=20000 + +# The stripcharts are updated every STRIPCHART_INTERVAL seconds. + +# STRIPCHART_INTERVAL=60 + +# A stripchart showing the count of messages in the queue is always +# displayed on the left of eximon's window. Its name is "queue" by +# default, but can be changed by this variable. + +# QUEUE_STRIPCHART_NAME=queue + +# The following variable may be set to the name of a disc partition. If +# it is, a stripchart showing the percentage fullness of the partition +# will be displayed as the second stripchart. This can be used to keep +# a display of a mail spool partition on the screen. + +# SIZE_STRIPCHART=/var/mail + +# The name of the size stripchart will be the last component of SIZE_STRIPCHART +# unless the following variable is set to override it. + +# SIZE_STRIPCHART_NAME=space + +# The following variable contains a specification of which stripcharts +# you want eximon to display based on log entries. The string consists of +# pairs of strings, delimited by slash characters. The first string in each +# pair is a regular expression that matches some distinguishing feature in a +# exim log entry. + +# Entries that match the expression will be counted and displayed in a +# stripchart whose title is given by the second string. The string may +# be continued over several input lines, provided that it is split +# after a slash, and an additional slash (optionally preceded by white +# space) is included at the start of the continuation line. + +# Stripcharts configured by the following parameter are displayed to the +# right of the queue and size stripcharts, in the order defined here. + +# LOG_STRIPCHARTS='/ <= /in/ +# / => /out/ +# / => .+ R=local/local/ +# / => .+ T=[^ ]*smtp/smtp/' + +# End of exim_monitor/EDITME diff --git a/exim_monitor/em_StripChart.c b/exim_monitor/em_StripChart.c new file mode 100644 index 0000000..3b94c22 --- /dev/null +++ b/exim_monitor/em_StripChart.c @@ -0,0 +1,504 @@ +/*********************************************************** +Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, +and the Massachusetts Institute of Technology, Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or MIT not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +/* This is the Athena StripChart widget, slightly hacked by +Philip Hazel <ph10@cus.cam.ac.uk> in order to give access to +its repaint_window function so that a repaint can be forced. + +The repaint_window function has also been nobbled so that it only +ever changes scale to 10. There is probably a better way to handle +this - such as inventing some new resources, but I'm not up to +that just at the moment. + +On SunOS4 there are name clashes when trying to link this with the +Athena library. So to avoid them, rename a few things by inserting +"my" at the front of "strip". */ + + +#include <stdio.h> +#include <X11/IntrinsicP.h> +#include <X11/StringDefs.h> +#include <X11/Xaw/XawInit.h> +#include <X11/Xaw/StripCharP.h> +#include <X11/Xfuncs.h> + +#define MS_PER_SEC 1000 + +/* Private Data */ + +#define offset(field) XtOffsetOf(StripChartRec, field) + +static XtResource resources[] = { + {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension), + offset(core.width), XtRImmediate, (XtPointer) 120}, + {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension), + offset(core.height), XtRImmediate, (XtPointer) 120}, + {XtNupdate, XtCInterval, XtRInt, sizeof(int), + offset(strip_chart.update), XtRImmediate, (XtPointer) 10}, + {XtNminScale, XtCScale, XtRInt, sizeof(int), + offset(strip_chart.min_scale), XtRImmediate, (XtPointer) 1}, + {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel), + offset(strip_chart.fgpixel), XtRString, XtDefaultForeground}, + {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel), + offset(strip_chart.hipixel), XtRString, XtDefaultForeground}, + {XtNgetValue, XtCCallback, XtRCallback, sizeof(XtPointer), + offset(strip_chart.get_value), XtRImmediate, (XtPointer) NULL}, + {XtNjumpScroll, XtCJumpScroll, XtRInt, sizeof(int), + offset(strip_chart.jump_val), XtRImmediate, (XtPointer) DEFAULT_JUMP}, +}; + +#undef offset + +/* Added argument types to these to shut picky compilers up. PH */ + +static void CreateGC(StripChartWidget, unsigned int); +static void DestroyGC(StripChartWidget, unsigned int); +static void Initialize(), Destroy(), Redisplay(); +static void MoveChart(StripChartWidget, Boolean); +static void SetPoints(StripChartWidget); +static Boolean SetValues(); + +int repaint_window(StripChartWidget, int, int); /* PH hack */ +/* static int repaint_window(); */ + +StripChartClassRec stripChartClassRec = { + { /* core fields */ + /* superclass */ (WidgetClass) &simpleClassRec, + /* class_name */ "StripChart", + /* size */ sizeof(StripChartRec), + /* class_initialize */ XawInitializeWidgetSet, + /* class_part_initialize */ NULL, + /* class_inited */ FALSE, + /* initialize */ Initialize, + /* initialize_hook */ NULL, + /* realize */ XtInheritRealize, + /* actions */ NULL, + /* num_actions */ 0, + /* resources */ resources, + /* num_resources */ XtNumber(resources), + /* xrm_class */ NULLQUARK, + /* compress_motion */ TRUE, + /* compress_exposure */ XtExposeCompressMultiple | + XtExposeGraphicsExposeMerged, + /* compress_enterleave */ TRUE, + /* visible_interest */ FALSE, + /* destroy */ Destroy, + /* resize */ (void (*)(Widget))SetPoints, + /* expose */ Redisplay, + /* set_values */ SetValues, + /* set_values_hook */ NULL, + /* set_values_almost */ NULL, + /* get_values_hook */ NULL, + /* accept_focus */ NULL, + /* version */ XtVersion, + /* callback_private */ NULL, + /* tm_table */ NULL, + /* query_geometry */ XtInheritQueryGeometry, + /* display_accelerator */ XtInheritDisplayAccelerator, + /* extension */ NULL + }, + { /* Simple class fields */ + /* change_sensitive */ XtInheritChangeSensitive + } +}; + +WidgetClass mystripChartWidgetClass = (WidgetClass) &stripChartClassRec; + +/**************************************************************** + * + * Private Procedures + * + ****************************************************************/ + +static void draw_it(); + +/* Function Name: CreateGC + * Description: Creates the GC's + * Arguments: w - the strip chart widget. + * which - which GC's to create. + * Returns: none + */ + +static void +CreateGC(w, which) +StripChartWidget w; +unsigned int which; +{ + XGCValues myXGCV; + + if (which & FOREGROUND) { + myXGCV.foreground = w->strip_chart.fgpixel; + w->strip_chart.fgGC = XtGetGC((Widget) w, GCForeground, &myXGCV); + } + + if (which & HIGHLIGHT) { + myXGCV.foreground = w->strip_chart.hipixel; + w->strip_chart.hiGC = XtGetGC((Widget) w, GCForeground, &myXGCV); + } +} + +/* Function Name: DestroyGC + * Description: Destroys the GC's + * Arguments: w - the strip chart widget. + * which - which GC's to destroy. + * Returns: none + */ + +static void +DestroyGC(w, which) +StripChartWidget w; +unsigned int which; +{ + if (which & FOREGROUND) + XtReleaseGC((Widget) w, w->strip_chart.fgGC); + + if (which & HIGHLIGHT) + XtReleaseGC((Widget) w, w->strip_chart.hiGC); +} + +/* ARGSUSED */ +static void Initialize (greq, gnew) + Widget greq, gnew; +{ + StripChartWidget w = (StripChartWidget)gnew; + + if (w->strip_chart.update > 0) + w->strip_chart.interval_id = XtAppAddTimeOut( + XtWidgetToApplicationContext(gnew), + w->strip_chart.update * MS_PER_SEC, + draw_it, (XtPointer) gnew); + CreateGC(w, (unsigned int) ALL_GCS); + + w->strip_chart.scale = w->strip_chart.min_scale; + w->strip_chart.interval = 0; + w->strip_chart.max_value = 0.0; + w->strip_chart.points = NULL; + SetPoints(w); +} + +static void Destroy (gw) + Widget gw; +{ + StripChartWidget w = (StripChartWidget)gw; + + if (w->strip_chart.update > 0) + XtRemoveTimeOut (w->strip_chart.interval_id); + if (w->strip_chart.points) + XtFree((char *) w->strip_chart.points); + DestroyGC(w, (unsigned int) ALL_GCS); +} + +/* + * NOTE: This function really needs to receive graphics exposure + * events, but since this is not easily supported until R4 I am + * going to hold off until then. + */ + +/* ARGSUSED */ +static void Redisplay(w, event, region) + Widget w; + XEvent *event; + Region region; +{ + if (event->type == GraphicsExpose) + (void) repaint_window ((StripChartWidget)w, event->xgraphicsexpose.x, + event->xgraphicsexpose.width); + else + (void) repaint_window ((StripChartWidget)w, event->xexpose.x, + event->xexpose.width); +} + +/* ARGSUSED */ +static void +draw_it(client_data, id) +XtPointer client_data; +XtIntervalId *id; /* unused */ +{ + StripChartWidget w = (StripChartWidget)client_data; + double value; + + if (w->strip_chart.update > 0) + w->strip_chart.interval_id = + XtAppAddTimeOut(XtWidgetToApplicationContext( (Widget) w), + w->strip_chart.update * MS_PER_SEC,draw_it,client_data); + + if (w->strip_chart.interval >= (int)w->core.width) + MoveChart( (StripChartWidget) w, TRUE); + + /* Get the value, stash the point and draw corresponding line. */ + + if (w->strip_chart.get_value == NULL) + return; + + XtCallCallbacks( (Widget)w, XtNgetValue, (XtPointer)&value ); + + /* + * Keep w->strip_chart.max_value up to date, and if this data + * point is off the graph, change the scale to make it fit. + */ + + if (value > w->strip_chart.max_value) { + w->strip_chart.max_value = value; + if (w->strip_chart.max_value > w->strip_chart.scale) { + XClearWindow( XtDisplay (w), XtWindow (w)); + w->strip_chart.interval = repaint_window(w, 0, (int) w->core.width); + } + } + + w->strip_chart.valuedata[w->strip_chart.interval] = value; + if (XtIsRealized((Widget)w)) { + int y = (int) (w->core.height + - (int)(w->core.height * value) / w->strip_chart.scale); + + XFillRectangle(XtDisplay(w), XtWindow(w), w->strip_chart.fgGC, + w->strip_chart.interval, y, + (unsigned int) 1, w->core.height - y); + /* + * Fill in the graph lines we just painted over. + */ + + if (w->strip_chart.points != NULL) { + w->strip_chart.points[0].x = w->strip_chart.interval; + XDrawPoints(XtDisplay(w), XtWindow(w), w->strip_chart.hiGC, + w->strip_chart.points, w->strip_chart.scale - 1, + CoordModePrevious); + } + + XFlush(XtDisplay(w)); /* Flush output buffers */ + } + w->strip_chart.interval++; /* Next point */ +} /* draw_it */ + +/* Blts data according to current size, then redraws the stripChart window. + * Next represents the number of valid points in data. Returns the (possibly) + * adjusted value of next. If next is 0, this routine draws an empty window + * (scale - 1 lines for graph). If next is less than the current window width, + * the returned value is identical to the initial value of next and data is + * unchanged. Otherwise keeps half a window's worth of data. If data is + * changed, then w->strip_chart.max_value is updated to reflect the + * largest data point. + */ + +/* static int */ +int /* PH hack */ +repaint_window(w, left, width) +StripChartWidget w; +int left, width; +{ + register int i, j; + register int next = w->strip_chart.interval; + int scale = w->strip_chart.scale; + int scalewidth = 0; + + /* Compute the minimum scale required to graph the data, but don't go + lower than min_scale. */ + if (w->strip_chart.interval != 0 || scale <= (int)w->strip_chart.max_value) + scale = ((int) (w->strip_chart.max_value)) + 1; + if (scale < w->strip_chart.min_scale) + scale = w->strip_chart.min_scale; + +/* if (scale != w->strip_chart.scale) { */ + + if (scale != w->strip_chart.scale && scale == 10) { + w->strip_chart.scale = scale; + left = 0; + width = next; + scalewidth = w->core.width; + + SetPoints(w); + + if (XtIsRealized ((Widget) w)) + XClearWindow (XtDisplay (w), XtWindow (w)); + + } + + if (XtIsRealized((Widget)w)) { + Display *dpy = XtDisplay(w); + Window win = XtWindow(w); + + width += left - 1; + if (!scalewidth) scalewidth = width; + + if (next < ++width) width = next; + + /* Draw data point lines. */ + for (i = left; i < width; i++) { + int y = (int) (w->core.height - + (int)(w->core.height * w->strip_chart.valuedata[i]) / + w->strip_chart.scale); + + XFillRectangle(dpy, win, w->strip_chart.fgGC, + i, y, (unsigned int) 1, + (unsigned int) (w->core.height - y)); + } + + /* Draw graph reference lines */ + for (i = 1; i < w->strip_chart.scale; i++) { + j = i * ((int)w->core.height / w->strip_chart.scale); + XDrawLine(dpy, win, w->strip_chart.hiGC, left, j, scalewidth, j); + } + } + return(next); +} + +/* Function Name: MoveChart + * Description: moves the chart over when it would run off the end. + * Arguments: w - the load widget. + * blit - blit the bits? (TRUE/FALSE). + * Returns: none. + */ + +static void +MoveChart(StripChartWidget w, Boolean blit) +{ + double old_max; + int left, i, j; + register int next = w->strip_chart.interval; + + if (!XtIsRealized((Widget) w)) return; + + if (w->strip_chart.jump_val == DEFAULT_JUMP) + j = w->core.width >> 1; /* Half the window width. */ + else { + j = w->core.width - w->strip_chart.jump_val; + if (j < 0) j = 0; + } + + bcopy((char *)(w->strip_chart.valuedata + next - j), + (char *)(w->strip_chart.valuedata), j * sizeof(double)); + next = w->strip_chart.interval = j; + + /* + * Since we just lost some data, recompute the + * w->strip_chart.max_value. + */ + + old_max = w->strip_chart.max_value; + w->strip_chart.max_value = 0.0; + for (i = 0; i < next; i++) { + if (w->strip_chart.valuedata[i] > w->strip_chart.max_value) + w->strip_chart.max_value = w->strip_chart.valuedata[i]; + } + + if (!blit) return; /* we are done... */ + + if ( ((int) old_max) != ( (int) w->strip_chart.max_value) ) { + XClearWindow(XtDisplay(w), XtWindow(w)); + repaint_window(w, 0, (int) w->core.width); + return; + } + + XCopyArea(XtDisplay((Widget)w), XtWindow((Widget)w), XtWindow((Widget)w), + w->strip_chart.hiGC, (int) w->core.width - j, 0, + (unsigned int) j, (unsigned int) w->core.height, + 0, 0); + + XClearArea(XtDisplay((Widget)w), XtWindow((Widget)w), + (int) j, 0, + (unsigned int) w->core.width - j, (unsigned int)w->core.height, + FALSE); + + /* Draw graph reference lines */ + left = j; + for (i = 1; i < w->strip_chart.scale; i++) { + j = i * ((int)w->core.height / w->strip_chart.scale); + XDrawLine(XtDisplay((Widget) w), XtWindow( (Widget) w), + w->strip_chart.hiGC, left, j, (int)w->core.width, j); + } + return; +} + +/* ARGSUSED */ +static Boolean SetValues (current, request, new) + Widget current, request, new; +{ + StripChartWidget old = (StripChartWidget)current; + StripChartWidget w = (StripChartWidget)new; + Boolean ret_val = FALSE; + unsigned int new_gc = NO_GCS; + + if (w->strip_chart.update != old->strip_chart.update) { + if (old->strip_chart.update > 0) + XtRemoveTimeOut (old->strip_chart.interval_id); + if (w->strip_chart.update > 0) + w->strip_chart.interval_id = + XtAppAddTimeOut(XtWidgetToApplicationContext(new), + w->strip_chart.update * MS_PER_SEC, + draw_it, (XtPointer)w); + } + + if ( w->strip_chart.min_scale > (int) ((w->strip_chart.max_value) + 1) ) + ret_val = TRUE; + + if ( w->strip_chart.fgpixel != old->strip_chart.fgpixel ) { + new_gc |= FOREGROUND; + ret_val = True; + } + + if ( w->strip_chart.hipixel != old->strip_chart.hipixel ) { + new_gc |= HIGHLIGHT; + ret_val = True; + } + + DestroyGC(old, new_gc); + CreateGC(w, new_gc); + + return( ret_val ); +} + +/* Function Name: SetPoints + * Description: Sets up the polypoint that will be used to draw in + * the graph lines. + * Arguments: w - the StripChart widget. + * Returns: none. + */ + +#define HEIGHT ( (unsigned int) w->core.height) + +static void +SetPoints(w) +StripChartWidget w; +{ + XPoint * points; + Cardinal size; + int i; + + if (w->strip_chart.scale <= 1) { /* no scale lines. */ + XtFree ((char *) w->strip_chart.points); + w->strip_chart.points = NULL; + return; + } + + size = sizeof(XPoint) * (w->strip_chart.scale - 1); + + points = (XPoint *) XtRealloc( (XtPointer) w->strip_chart.points, size); + w->strip_chart.points = points; + + /* Draw graph reference lines into clip mask */ + + for (i = 1; i < w->strip_chart.scale; i++) { + points[i - 1].x = 0; + points[i - 1].y = HEIGHT / w->strip_chart.scale; + } +} diff --git a/exim_monitor/em_TextPop.c b/exim_monitor/em_TextPop.c new file mode 100644 index 0000000..7e8a2eb --- /dev/null +++ b/exim_monitor/em_TextPop.c @@ -0,0 +1,767 @@ +/*********************************************************** +Copyright 1989 by the Massachusetts Institute of Technology, +Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or MIT not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + + +/**************************************************************************** +* Modified by Philip Hazel for use with Exim. The "replace" and "insert * +* file" features of the search facility have been removed. Also took out * +* the declaration of sys_errlist, as it isn't used and causes trouble on * +* some systems that declare it differently. September 1996. * +* Added the arguments into the static functions declared at the head, to * +* stop some compiler warnings. August 1999. * +* Took out the separate declarations of errno and sys_nerr at the start, * +* because they too aren't actually used, and the declaration causes trouble * +* on some systems. December 2002. * +****************************************************************************/ + + +/************************************************************ + * + * This file is broken up into three sections one dealing with + * each of the three popups created here: + * + * FileInsert, Search, and Replace. + * + * There is also a section at the end for utility functions + * used by all more than one of these dialogs. + * + * The following functions are the only non-static ones defined + * in this module. They are located at the beginning of the + * section that contains this dialog box that uses them. + * + * void _XawTextInsertFileAction(w, event, params, num_params); + * void _XawTextDoSearchAction(w, event, params, num_params); + * void _XawTextDoReplaceAction(w, event, params, num_params); + * void _XawTextInsertFile(w, event, params, num_params); + * + *************************************************************/ + +#include <X11/IntrinsicP.h> +#include <X11/StringDefs.h> +#include <X11/Shell.h> + +#include <X11/Xaw/TextP.h> +#include <X11/Xaw/AsciiText.h> +#include <X11/Xaw/Cardinals.h> +#include <X11/Xaw/Command.h> +#include <X11/Xaw/Form.h> +#include <X11/Xaw/Toggle.h> +#include <X11/Xmu/CharSet.h> +#include <stdio.h> +#include <X11/Xos.h> /* for O_RDONLY */ +#include <errno.h> + +/* extern int errno, sys_nerr; */ +/* extern char* sys_errlist[]; */ + +#define DISMISS_NAME ("cancel") +#define DISMISS_NAME_LEN 6 +#define FORM_NAME ("form") +#define LABEL_NAME ("label") +#define TEXT_NAME ("text") + +#define R_OFFSET 1 + +/* Argument types added by PH August 1999 */ + +static void CenterWidgetOnPoint(Widget, XEvent *); +static void PopdownSearch(Widget, XtPointer, XtPointer); +static void InitializeSearchWidget(struct SearchAndReplace *, + XawTextScanDirection, Boolean); +static void SetResource(Widget, char *, XtArgVal); +static void SetSearchLabels(struct SearchAndReplace *, String, String, + Boolean); +static Widget CreateDialog(Widget, String, String, + void (*)(Widget, char *, Widget)); +static Widget GetShell(Widget); +static void SetWMProtocolTranslations(Widget w); +static Boolean DoSearch(struct SearchAndReplace *); +static String GetString(Widget); + +static void AddSearchChildren(Widget, char *, Widget); + +static char radio_trans_string[] = + "<Btn1Down>,<Btn1Up>: set() notify()"; + +static char search_text_trans[] = + "~Shift<Key>Return: DoSearchAction(Popdown) \n\ + Ctrl<Key>c: PopdownSearchAction() \n\ + "; + + + +/************************************************************ + * + * This section of the file contains all the functions that + * the search dialog box uses. + * + ************************************************************/ + +/* Function Name: _XawTextDoSearchAction + * Description: Action routine that can be bound to dialog box's + * Text Widget that will search for a string in the main + * Text Widget. + * Arguments: (Standard Action Routine args) + * Returns: none. + * + * Note: + * + * If the search was successful and the argument popdown is passed to + * this action routine then the widget will automatically popdown the + * search widget. + */ + +/* ARGSUSED */ +void +_XawTextDoSearchAction(w, event, params, num_params) +Widget w; +XEvent *event; +String * params; +Cardinal * num_params; +{ + TextWidget tw = (TextWidget) XtParent(XtParent(XtParent(w))); + Boolean popdown = FALSE; + + if ( (*num_params == 1) && + ((params[0][0] == 'p') || (params[0][0] == 'P')) ) + popdown = TRUE; + + if (DoSearch(tw->text.search) && popdown) + PopdownSearch(w, (XtPointer) tw->text.search, NULL); +} + +/* Function Name: _XawTextPopdownSearchAction + * Description: Action routine that can be bound to dialog box's + * Text Widget that will popdown the search widget. + * Arguments: (Standard Action Routine args) + * Returns: none. + */ + +/* ARGSUSED */ +void +_XawTextPopdownSearchAction(w, event, params, num_params) +Widget w; +XEvent *event; +String * params; +Cardinal * num_params; +{ + TextWidget tw = (TextWidget) XtParent(XtParent(XtParent(w))); + + PopdownSearch(w, (XtPointer) tw->text.search, NULL); +} + +/* Function Name: PopdownSearch + * Description: Pops down the search widget and resets it. + * Arguments: w - *** NOT USED ***. + * closure - a pointer to the search structure. + * call_data - *** NOT USED ***. + * Returns: none + */ + +/* ARGSUSED */ +static void +PopdownSearch(w, closure, call_data) +Widget w; +XtPointer closure; +XtPointer call_data; +{ + struct SearchAndReplace * search = (struct SearchAndReplace *) closure; + + SetSearchLabels(search, "Search", "", FALSE); + XtPopdown( search->search_popup ); +} + +/* Function Name: SearchButton + * Description: Performs a search when the button is clicked. + * Arguments: w - *** NOT USED **. + * closure - a pointer to the search info. + * call_data - *** NOT USED ***. + * Returns: + */ + +/* ARGSUSED */ +static void +SearchButton(w, closure, call_data) +Widget w; +XtPointer closure; +XtPointer call_data; +{ + (void) DoSearch( (struct SearchAndReplace *) closure ); +} + +/* Function Name: _XawTextSearch + * Description: Action routine that can be bound to the text widget + * it will popup the search dialog box. + * Arguments: w - the text widget. + * event - X Event (used to get x and y location). + * params, num_params - the parameter list. + * Returns: none. + * + * NOTE: + * + * The parameter list contains one or two entries that may be the following. + * + * First Entry: The first entry is the direction to search by default. + * This argument must be specified and may have a value of + * "left" or "right". + * + * Second Entry: This entry is optional and contains the value of the default + * string to search for. + */ + +#define SEARCH_HEADER ("Text Widget - Search():") + +void +_XawTextSearch(w, event, params, num_params) +Widget w; +XEvent *event; +String * params; +Cardinal * num_params; +{ + TextWidget ctx = (TextWidget)w; + XawTextScanDirection dir; + char * ptr, buf[BUFSIZ]; + XawTextEditType edit_mode; + Arg args[1]; + +#ifdef notdef + if (ctx->text.source->Search == NULL) { + XBell(XtDisplay(w), 0); + return; + } +#endif + + if ( (*num_params < 1) || (*num_params > 2) ) { + sprintf(buf, "%s %s\n%s", SEARCH_HEADER, "This action must have only", + "one or two parameters"); + XtAppWarning(XtWidgetToApplicationContext(w), buf); + return; + } + else if (*num_params == 1) + ptr = ""; + else + ptr = params[1]; + + switch(params[0][0]) { + case 'b': /* Left. */ + case 'B': + dir = XawsdLeft; + break; + case 'f': /* Right. */ + case 'F': + dir = XawsdRight; + break; + default: + sprintf(buf, "%s %s\n%s", SEARCH_HEADER, "The first parameter must be", + "Either 'backward' or 'forward'"); + XtAppWarning(XtWidgetToApplicationContext(w), buf); + return; + } + + if (ctx->text.search== NULL) { + ctx->text.search = XtNew(struct SearchAndReplace); + ctx->text.search->search_popup = CreateDialog(w, ptr, "search", + AddSearchChildren); + XtRealizeWidget(ctx->text.search->search_popup); + SetWMProtocolTranslations(ctx->text.search->search_popup); + } + else if (*num_params > 1) { + XtVaSetValues(ctx->text.search->search_text, XtNstring, ptr, NULL); + } + + XtSetArg(args[0], XtNeditType,&edit_mode); + XtGetValues(ctx->text.source, args, ONE); + + InitializeSearchWidget(ctx->text.search, dir, (edit_mode == XawtextEdit)); + + CenterWidgetOnPoint(ctx->text.search->search_popup, event); + XtPopup(ctx->text.search->search_popup, XtGrabNone); +} + +/* Function Name: InitializeSearchWidget + * Description: This function initializes the search widget and + * is called each time the search widget is poped up. + * Arguments: search - the search widget structure. + * dir - direction to search. + * replace_active - state of the sensitivity for the + * replace button. + * Returns: none. + */ + +static void +InitializeSearchWidget(struct SearchAndReplace *search, + XawTextScanDirection dir, Boolean replace_active) +{ +replace_active = replace_active; /* PH - shuts compilers up */ + + switch (dir) { + case XawsdLeft: + SetResource(search->left_toggle, XtNstate, (XtArgVal) TRUE); + break; + case XawsdRight: + SetResource(search->right_toggle, XtNstate, (XtArgVal) TRUE); + break; + default: + break; + } +} + +/* Function Name: AddSearchChildren + * Description: Adds all children to the Search Dialog Widget. + * Arguments: form - the form widget for the search widget. + * ptr - a pointer to the initial string for the Text Widget. + * tw - the main text widget. + * Returns: none. + */ + +static void +AddSearchChildren(form, ptr, tw) +Widget form, tw; +char * ptr; +{ + Arg args[10]; + Cardinal num_args; + Widget cancel, search_button, s_label, s_text; + XtTranslations trans; + struct SearchAndReplace * search = ((TextWidget) tw)->text.search; + + num_args = 0; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNresizable, TRUE ); num_args++; + XtSetArg(args[num_args], XtNborderWidth, 0 ); num_args++; + search->label1 = XtCreateManagedWidget("label1", labelWidgetClass, + form, args, num_args); + + /* + * We need to add R_OFFSET to the radio_data, because the value zero (0) + * has special meaning. + */ + + num_args = 0; + XtSetArg(args[num_args], XtNlabel, "Backward"); num_args++; + XtSetArg(args[num_args], XtNfromVert, search->label1); num_args++; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNradioData, (caddr_t) XawsdLeft + R_OFFSET); + num_args++; + search->left_toggle = XtCreateManagedWidget("backwards", toggleWidgetClass, + form, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNlabel, "Forward"); num_args++; + XtSetArg(args[num_args], XtNfromVert, search->label1); num_args++; + XtSetArg(args[num_args], XtNfromHoriz, search->left_toggle); num_args++; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNradioGroup, search->left_toggle); num_args++; + XtSetArg(args[num_args], XtNradioData, (caddr_t) XawsdRight + R_OFFSET); + num_args++; + search->right_toggle = XtCreateManagedWidget("forwards", toggleWidgetClass, + form, args, num_args); + + { + XtTranslations radio_translations; + + radio_translations = XtParseTranslationTable(radio_trans_string); + XtOverrideTranslations(search->left_toggle, radio_translations); + XtOverrideTranslations(search->right_toggle, radio_translations); + } + + num_args = 0; + XtSetArg(args[num_args], XtNfromVert, search->left_toggle); num_args++; + XtSetArg(args[num_args], XtNlabel, "Search for: ");num_args++; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNborderWidth, 0 ); num_args++; + s_label = XtCreateManagedWidget("searchLabel", labelWidgetClass, + form, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNfromVert, search->left_toggle); num_args++; + XtSetArg(args[num_args], XtNfromHoriz, s_label); num_args++; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainRight); num_args++; + XtSetArg(args[num_args], XtNeditType, XawtextEdit); num_args++; + XtSetArg(args[num_args], XtNresizable, TRUE); num_args++; + XtSetArg(args[num_args], XtNresize, XawtextResizeWidth); num_args++; + XtSetArg(args[num_args], XtNstring, ptr); num_args++; + s_text = XtCreateManagedWidget("searchText", asciiTextWidgetClass, form, + args, num_args); + search->search_text = s_text; + + num_args = 0; + XtSetArg(args[num_args], XtNlabel, "Search"); num_args++; + XtSetArg(args[num_args], XtNfromVert, s_text); num_args++; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++; + search_button = XtCreateManagedWidget("search", commandWidgetClass, form, + args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNlabel, "Cancel"); num_args++; + XtSetArg(args[num_args], XtNfromVert, s_text); num_args++; + XtSetArg(args[num_args], XtNfromHoriz, search_button); num_args++; + XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++; + cancel = XtCreateManagedWidget(DISMISS_NAME, commandWidgetClass, form, + args, num_args); + + XtAddCallback(search_button, XtNcallback, SearchButton, (XtPointer) search); + XtAddCallback(cancel, XtNcallback, PopdownSearch, (XtPointer) search); + +/* + * Initialize the text entry fields. + */ + + SetSearchLabels(search, "Search", "", FALSE); + XtSetKeyboardFocus(form, search->search_text); + +/* + * Bind Extra translations. + */ + + trans = XtParseTranslationTable(search_text_trans); + XtOverrideTranslations(search->search_text, trans); +} + +/* Function Name: DoSearch + * Description: Performs a search. + * Arguments: search - the search structure. + * Returns: TRUE if successful. + */ + +/* ARGSUSED */ +static Boolean +DoSearch(search) +struct SearchAndReplace * search; +{ + char msg[BUFSIZ]; + Widget tw = XtParent(search->search_popup); + XawTextPosition pos; + XawTextScanDirection dir; + XawTextBlock text; + + text.ptr = GetString(search->search_text); + text.length = strlen(text.ptr); + text.firstPos = 0; + text.format = FMT8BIT; + + dir = (XawTextScanDirection) ((long)XawToggleGetCurrent(search->left_toggle) - + R_OFFSET); + + pos = XawTextSearch( tw, dir, &text); + + if (pos == XawTextSearchError) + sprintf( msg, "Could not find string '%s'.", text.ptr); + else { + if (dir == XawsdRight) + XawTextSetInsertionPoint( tw, pos + text.length); + else + XawTextSetInsertionPoint( tw, pos); + + XawTextSetSelection( tw, pos, pos + text.length); + search->selection_changed = FALSE; /* selection is good. */ + return(TRUE); + } + + XawTextUnsetSelection(tw); + SetSearchLabels(search, msg, "", TRUE); + return(FALSE); +} + + +/* Function Name: SetSearchLabels + * Description: Sets both the search labels, and also rings the bell + * HACKED: Only one label needed now + * Arguments: search - the search structure. + * msg1, msg2 - message to put in each search label. + * bell - if TRUE then ring bell. + * Returns: none. + */ + +static void +SetSearchLabels(struct SearchAndReplace *search, String msg1, String msg2, + Boolean bell) +{ +msg2 = msg2; /* PH - shuts compilers up */ + (void) SetResource( search->label1, XtNlabel, (XtArgVal) msg1); + /* (void) SetResource( search->label2, XtNlabel, (XtArgVal) msg2); */ + if (bell) + XBell(XtDisplay(search->search_popup), 0); +} + +/************************************************************ + * + * This section of the file contains utility routines used by + * other functions in this file. + * + ************************************************************/ + + +/* Function Name: SetResource + * Description: Sets a resource in a widget + * Arguments: w - the widget. + * res_name - name of the resource. + * value - the value of the resource. + * Returns: none. + */ + +static void +SetResource(w, res_name, value) +Widget w; +char * res_name; +XtArgVal value; +{ + Arg args[1]; + + XtSetArg(args[0], res_name, value); + XtSetValues( w, args, ONE ); +} + +/* Function Name: GetString + * Description: Gets the value for the string in the popup. + * Arguments: text - the text widget whose string we will get. + * Returns: the string. + */ + +static String +GetString(text) +Widget text; +{ + String string; + Arg args[1]; + + XtSetArg( args[0], XtNstring, &string ); + XtGetValues( text, args, ONE ); + return(string); +} + +/* Function Name: CenterWidgetOnPoint. + * Description: Centers a shell widget on a point relative to + * the root window. + * Arguments: w - the shell widget. + * event - event containing the location of the point + * Returns: none. + * + * NOTE: The widget is not allowed to go off the screen. + */ + +static void +CenterWidgetOnPoint(w, event) +Widget w; +XEvent *event; +{ + Arg args[3]; + Cardinal num_args; + Dimension width, height, b_width; + Position x=0, y=0, max_x, max_y; + + if (event != NULL) { + switch (event->type) { + case ButtonPress: + case ButtonRelease: + x = event->xbutton.x_root; + y = event->xbutton.y_root; + break; + case KeyPress: + case KeyRelease: + x = event->xkey.x_root; + y = event->xkey.y_root; + break; + default: + return; + } + } + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, &width); num_args++; + XtSetArg(args[num_args], XtNheight, &height); num_args++; + XtSetArg(args[num_args], XtNborderWidth, &b_width); num_args++; + XtGetValues(w, args, num_args); + + width += 2 * b_width; + height += 2 * b_width; + + x -= ( (Position) width/2 ); + if (x < 0) x = 0; + if ( x > (max_x = (Position) (XtScreen(w)->width - width)) ) x = max_x; + + y -= ( (Position) height/2 ); + if (y < 0) y = 0; + if ( y > (max_y = (Position) (XtScreen(w)->height - height)) ) y = max_y; + + num_args = 0; + XtSetArg(args[num_args], XtNx, x); num_args++; + XtSetArg(args[num_args], XtNy, y); num_args++; + XtSetValues(w, args, num_args); +} + +/* Function Name: CreateDialog + * Description: Actually creates a dialog. + * Arguments: parent - the parent of the dialog - the main text widget. + * ptr - initial_string for the dialog. + * name - name of the dialog. + * func - function to create the children of the dialog. + * Returns: the popup shell of the dialog. + * + * NOTE: + * + * The function argument is passed the following arguments. + * + * form - the from widget that is the dialog. + * ptr - the initial string for the dialog's text widget. + * parent - the parent of the dialog - the main text widget. + */ + +static Widget +CreateDialog(parent, ptr, name, func) +Widget parent; +String ptr, name; +void (*func)(); +{ + Widget popup, form; + Arg args[5]; + Cardinal num_args; + + num_args = 0; + XtSetArg(args[num_args], XtNiconName, name); num_args++; + XtSetArg(args[num_args], XtNgeometry, NULL); num_args++; + XtSetArg(args[num_args], XtNallowShellResize, TRUE); num_args++; + XtSetArg(args[num_args], XtNtransientFor, GetShell(parent)); num_args++; + popup = XtCreatePopupShell(name, transientShellWidgetClass, + parent, args, num_args); + + form = XtCreateManagedWidget(FORM_NAME, formWidgetClass, popup, + NULL, ZERO); + + (*func) (form, ptr, parent); + return(popup); +} + + /* Function Name: GetShell + * Description: Walks up the widget hierarchy to find the + * nearest shell widget. + * Arguments: w - the widget whose parent shell should be returned. + * Returns: The shell widget among the ancestors of w that is the + * fewest levels up in the widget hierarchy. + */ + +static Widget +GetShell(w) +Widget w; +{ + while ((w != NULL) && !XtIsShell(w)) + w = XtParent(w); + + return (w); +} + +/* Add proper prototype to keep IRIX 6 compiler happy. PH */ + +static Boolean InParams(String, String *, Cardinal); + +static Boolean InParams(str, p, n) + String str; + String *p; + Cardinal n; +{ + int i; + for (i=0; i < n; p++, i++) + if (! XmuCompareISOLatin1(*p, str)) return True; + return False; +} + +static char *WM_DELETE_WINDOW = "WM_DELETE_WINDOW"; + +static void WMProtocols(w, event, params, num_params) + Widget w; /* popup shell */ + XEvent *event; + String *params; + Cardinal *num_params; +{ + Atom wm_delete_window; + Atom wm_protocols; + + wm_delete_window = XInternAtom(XtDisplay(w), WM_DELETE_WINDOW, True); + wm_protocols = XInternAtom(XtDisplay(w), "WM_PROTOCOLS", True); + + /* Respond to a recognized WM protocol request iff + * event type is ClientMessage and no parameters are passed, or + * event type is ClientMessage and event data is matched to parameters, or + * event type isn't ClientMessage and parameters make a request. + */ +#define DO_DELETE_WINDOW InParams(WM_DELETE_WINDOW, params, *num_params) + + if ((event->type == ClientMessage && + event->xclient.message_type == wm_protocols && + event->xclient.data.l[0] == wm_delete_window && + (*num_params == 0 || DO_DELETE_WINDOW)) + || + (event->type != ClientMessage && DO_DELETE_WINDOW)) { + +#undef DO_DELETE_WINDOW + + Widget cancel; + char descendant[DISMISS_NAME_LEN + 2]; + sprintf(descendant, "*%s", DISMISS_NAME); + cancel = XtNameToWidget(w, descendant); + if (cancel) XtCallCallbacks(cancel, XtNcallback, (XtPointer)NULL); + } +} + +static void SetWMProtocolTranslations(w) + Widget w; /* realized popup shell */ +{ + int i; + XtAppContext app_context; + Atom wm_delete_window; + static XtTranslations compiled_table; /* initially 0 */ + static XtAppContext *app_context_list; /* initially 0 */ + static Cardinal list_size; /* initially 0 */ + + app_context = XtWidgetToApplicationContext(w); + + /* parse translation table once */ + if (! compiled_table) compiled_table = XtParseTranslationTable + ("<Message>WM_PROTOCOLS: XawWMProtocols()\n"); + + /* add actions once per application context */ + for (i=0; i < list_size && app_context_list[i] != app_context; i++) ; + if (i == list_size) { + XtActionsRec actions[1]; + actions[0].string = "XawWMProtocols"; + actions[0].proc = WMProtocols; + list_size++; + app_context_list = (XtAppContext *) XtRealloc + ((char *)app_context_list, list_size * sizeof(XtAppContext)); + XtAppAddActions(app_context, actions, 1); + app_context_list[i] = app_context; + } + + /* establish communication between the window manager and each shell */ + XtAugmentTranslations(w, compiled_table); + wm_delete_window = XInternAtom(XtDisplay(w), WM_DELETE_WINDOW, False); + (void) XSetWMProtocols(XtDisplay(w), XtWindow(w), &wm_delete_window, 1); +} diff --git a/exim_monitor/em_globals.c b/exim_monitor/em_globals.c new file mode 100644 index 0000000..30d22b5 --- /dev/null +++ b/exim_monitor/em_globals.c @@ -0,0 +1,237 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2018 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +#include "em_hdr.h" + +/* This source module contains all the global variables used in +the exim monitor, including those that are used by the standard +Exim modules that are included in Eximon. For comments on their +usage, see em_hdr.h and globals.h. */ + + +/* The first set are unique to Eximon */ + +Display *X_display; +XtAppContext X_appcon; + +XtActionsRec actionTable[] = { + { "dialogAction", (XtActionProc)dialogAction}}; + +int actionTableSize = sizeof(actionTable)/sizeof(XtActionsRec); + +XtTranslations queue_trans; +XtTranslations text_trans; + +Widget dialog_ref_widget; +Widget toplevel_widget; +Widget log_widget = NULL; +Widget queue_widget; +Widget unhide_widget = NULL; + + +FILE *LOG; + +int action_output = FALSE; +int action_queue_update = TRUE; +uschar actioned_message[24]; +uschar *action_required; +uschar *alternate_config = NULL; + +#ifdef EXPERIMENTAL_BRIGHTMAIL +int bmi_run = 0; +uschar *bmi_verdicts = NULL; +#endif + +int body_max = 20000; + +uschar *exim_path = US BIN_DIRECTORY "/exim" + "\0<---------------Space to patch exim_path->"; + +int eximon_initialized = FALSE; + +int log_buffer_size = 10240; +BOOL log_datestamping = FALSE; +int log_depth = 150; +uschar *log_display_buffer; +uschar *log_file = NULL; +uschar log_file_open[256]; +uschar *log_font = NULL; +ino_t log_inode; +long int log_position; +int log_width = 600; + +uschar *menu_event = US"Shift<Btn1Down>"; +int menu_is_up = FALSE; +int min_height = 162; +int min_width = 103; + +pipe_item *pipe_chain = NULL; + +uschar *qualify_domain = NULL; +int queue_depth = 200; +uschar *queue_font = NULL; +int queue_max_addresses = 10; +skip_item *queue_skip = NULL; +uschar *queue_stripchart_name = NULL; +int queue_update = 60; +int queue_width = 600; + +pcre *yyyymmdd_regex; + +uschar *size_stripchart = NULL; +uschar *size_stripchart_name = NULL; +int spool_is_split = FALSE; +int start_small = FALSE; +int stripchart_height = 90; +int stripchart_number = 1; +pcre **stripchart_regex; +uschar **stripchart_title; +int *stripchart_total; +int stripchart_update = 60; +int stripchart_width = 80; +int stripchart_varstart = 1; + +int text_depth = 200; +int tick_queue_accumulator = 999999; + +uschar *window_title = US"exim monitor"; + + +/***********************************************************/ +/***********************************************************/ + + +/* These ones are used by Exim modules included in Eximon. Not all are +actually relevant to the operation of Eximon. If SPOOL_DIRECTORY is not +defined (Exim was compiled with it unset), just define it empty. The script +that fires up the monitor fishes the value out by using -bP anyway. */ + +#ifndef SPOOL_DIRECTORY +#define SPOOL_DIRECTORY "" +#endif + +tree_node *acl_var_c = NULL; +tree_node *acl_var_m = NULL; +uschar *active_hostname = NULL; +BOOL allow_unqualified_recipient = FALSE; +BOOL allow_unqualified_sender = FALSE; +uschar *authenticated_id = NULL; +uschar *authenticated_sender = NULL; + +uschar *big_buffer = NULL; +int big_buffer_size = BIG_BUFFER_SIZE; +int body_linecount = 0; +int body_zerocount = 0; + +BOOL deliver_firsttime = FALSE; +BOOL deliver_freeze = FALSE; +time_t deliver_frozen_at = 0; +BOOL deliver_manual_thaw = FALSE; + +#ifndef DISABLE_DKIM +uschar *dkim_cur_signer = NULL; +uschar *dkim_signers = NULL; +uschar *dkim_signing_domain = NULL; +uschar *dkim_signing_selector = NULL; +uschar *dkim_verify_signers = US"$dkim_signers"; +unsigned dkim_collect_input = 0; +BOOL dkim_disable_verify = FALSE; +#endif + +BOOL dont_deliver = FALSE; + +int dsn_ret = 0; +uschar *dsn_envid = NULL; + +struct global_flags f = { + .sender_local = FALSE, +}; + +#ifdef WITH_CONTENT_SCAN +int fake_response = OK; +#endif + +header_line *header_last = NULL; +header_line *header_list = NULL; + +BOOL host_lookup_deferred = FALSE; +BOOL host_lookup_failed = FALSE; +uschar *interface_address = NULL; +int interface_port = 0; + +BOOL local_error_message = FALSE; +uschar *local_scan_data = NULL; +BOOL log_timezone = FALSE; + +#ifdef WITH_CONTENT_SCAN +uschar *spam_bar = NULL; +uschar *spam_report = NULL; +uschar *spam_score = NULL; +uschar *spam_score_int = NULL; +#endif + +int max_received_linelength= 0; +int message_age = 0; +uschar *message_id; +uschar *message_id_external; +uschar message_id_option[MESSAGE_ID_LENGTH + 3]; + +int message_linecount = 0; +int message_size = 0; +uschar message_subdir[2] = { 0, 0 }; + +gid_t originator_gid; +uschar *originator_login; +uid_t originator_uid; + +uschar *primary_hostname = NULL; + +uschar *queue_name = US""; + +int received_count = 0; +uschar *received_protocol = NULL; +struct timeval received_time = { 0, 0 }; +int recipients_count = 0; +recipient_item *recipients_list = NULL; +int recipients_list_max = 0; +BOOL running_in_test_harness=FALSE; + +uschar *sender_address = NULL; +uschar *sender_fullhost = NULL; +uschar *sender_helo_name = NULL; +uschar *sender_host_address = NULL; +uschar *sender_host_auth_pubname = NULL; +uschar *sender_host_authenticated = NULL; +uschar *sender_host_name = NULL; +int sender_host_port = 0; +uschar *sender_ident = NULL; +BOOL sender_set_untrusted = FALSE; +uschar *smtp_active_hostname = NULL; + +BOOL split_spool_directory = FALSE; +uschar *spool_directory = US SPOOL_DIRECTORY; +int string_datestamp_offset=-1; +int string_datestamp_length= 0; +int string_datestamp_type = -1; + +BOOL timestamps_utc = FALSE; +tls_support tls_in = { + .active = { .sock = -1 } + /* remainder zero/null/false */ +}; + +tree_node *tree_duplicates = NULL; +tree_node *tree_nonrecipients = NULL; +tree_node *tree_unusable = NULL; + +uschar *version_date = US"?"; +uschar *version_string = US"?"; + +int warning_count = 0; + +/* End of em_globals.c */ diff --git a/exim_monitor/em_hdr.h b/exim_monitor/em_hdr.h new file mode 100644 index 0000000..c45f9fc --- /dev/null +++ b/exim_monitor/em_hdr.h @@ -0,0 +1,326 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2009 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +/* This is the general header file for all the modules that comprise +the exim monitor program. */ + +/* If this macro is defined, Eximon will anonymize all email addresses. This +feature is just so that screen shots can be obtained for documentation +purposes! */ + +/* #define ANONYMIZE */ + +/* System compilation parameters */ + +#define queue_index_size 10 /* Size of index into queue */ + +/* Assume most systems have statfs() unless os.h undefines this macro */ + +#define HAVE_STATFS + +/* Bring in the system-dependent stuff */ + +#include "os.h" + + +/* ANSI C includes */ + +#include <ctype.h> +#include <setjmp.h> +#include <signal.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Not-fully-ANSI systems (e.g. SunOS4 are missing some things) */ + +#ifndef SEEK_SET +#define SEEK_SET 0 +#define SEEK_CUR 1 +#define SEEK_END 2 +#endif + +/* Unix includes */ + +#include <sys/types.h> +#include <errno.h> +#include <dirent.h> +#include <fcntl.h> +#include <pwd.h> +#include <grp.h> +#include <sys/param.h> +#include <sys/stat.h> +#include <unistd.h> + +/* The new standard is statvfs; some OS have statfs. Also arrange +to be able to cut it out altogether for way-out OS that don't have +anything. */ + +#ifdef HAVE_STATFS +#ifdef HAVE_SYS_STATVFS_H +#include <sys/statvfs.h> + +#else + #define statvfs statfs + #ifdef HAVE_SYS_VFS_H + #include <sys/vfs.h> + #ifdef HAVE_SYS_STATFS_H + #include <sys/statfs.h> + #endif + #endif + #ifdef HAVE_SYS_MOUNT_H + #include <sys/mount.h> + #endif +#endif +#endif + +#include <sys/wait.h> + +/* Regular expression include */ + +#include <pcre.h> + +/* Includes from the main source of Exim. One of these days I should tidy up +this interface so that this kind of kludge isn't needed. */ + +#ifndef NS_MAXMSG +# define NS_MAXMSG 65535 +#endif +typedef void hctx; + +#include "local_scan.h" +#include "macros.h" +#include "structs.h" +#include "blob.h" +#include "globals.h" +#include "dbstuff.h" +#include "functions.h" +#include "osfunctions.h" + +/* The sys/resource.h header on SunOS 4 causes trouble with the gcc +compiler. Just stuff the bit we want in here; pragmatic easy way out. */ + +#ifdef NO_SYS_RESOURCE_H +#define RLIMIT_NOFILE 6 /* maximum descriptor index + 1 */ +struct rlimit { + int rlim_cur; /* current (soft) limit */ + int rlim_max; /* maximum value for rlim_cur */ +}; +#else +#include <sys/time.h> +#include <sys/resource.h> +#endif + +/* X11 includes */ + +#include <X11/Xlib.h> +#include <X11/Intrinsic.h> +#include <X11/StringDefs.h> +#include <X11/cursorfont.h> +#include <X11/keysym.h> +#include <X11/Shell.h> +#include <X11/Xaw/AsciiText.h> +#include <X11/Xaw/Command.h> +#include <X11/Xaw/Form.h> +#include <X11/Xaw/Dialog.h> +#include <X11/Xaw/Label.h> +#include <X11/Xaw/SimpleMenu.h> +#include <X11/Xaw/SmeBSB.h> +#include <X11/Xaw/SmeLine.h> +#include <X11/Xaw/TextSrc.h> +#include <X11/Xaw/TextSink.h> + +/* These are required because exim monitor has its own munged +version of the stripchart widget. */ + +#include <X11/IntrinsicP.h> +#include <X11/StringDefs.h> +#include <X11/Xaw/XawInit.h> +#include <X11/Xaw/StripCharP.h> + +extern WidgetClass mystripChartWidgetClass; + + + +/************************************************* +* Enumerations * +*************************************************/ + +/* Operations on the in-store message queue */ + +enum { queue_noop, queue_add }; + +/* Operations on the destinations queue */ + +enum { dest_noop, dest_add, dest_remove }; + + +/************************************************* +* Structure for destinations * +*************************************************/ + +typedef struct dest_item { + struct dest_item *next; + struct dest_item *parent; + uschar address[1]; +} dest_item; + + + +/************************************************* +* Structure for queue items * +*************************************************/ + +typedef struct queue_item { + struct queue_item *next; + struct queue_item *prev; + struct dest_item *destinations; + int input_time; + int update_time; + int size; + uschar *sender; + uschar name[17]; + uschar seen; + uschar frozen; + uschar dir_char; +} queue_item; + + +/************************************************* +* Structure for queue skip items * +*************************************************/ + +typedef struct skip_item { + struct skip_item *next; + time_t reveal; + uschar text[1]; +} skip_item; + + +/************************************************* +* Structure for delivery displays * +*************************************************/ + +typedef struct pipe_item { + struct pipe_item *next; + int fd; + Widget widget; +} pipe_item; + + + +/************************************************* +* Global variables * +*************************************************/ + +extern Display *X_display; /* Current display */ +extern XtAppContext X_appcon; /* Application context */ +extern XtActionsRec actionTable[]; /* Actions table */ + +extern XtTranslations queue_trans; /* translation table for queue text widget */ +extern XtTranslations text_trans; /* translation table for other text widgets */ + +extern Widget dialog_ref_widget; /* for positioning dialog box */ +extern Widget toplevel_widget; +extern Widget log_widget; /* widget for tail display */ +extern Widget queue_widget; /* widget for queue display */ +extern Widget unhide_widget; /* widget for unhide button */ + +extern FILE *LOG; + +extern int action_output; /* TRUE when wanting action command output */ +extern int action_queue_update; /* controls auto updates */ +extern int actionTableSize; /* # entries in actionTable */ +extern uschar actioned_message[]; /* For menu handling */ +extern uschar *action_required; +extern uschar *alternate_config; /* Alternate Exim configuration file */ + +extern int body_max; /* Max size of body to display */ + +extern int eximon_initialized; /* TRUE when initialized */ + +extern int log_buffer_size; /* size of log buffer */ +extern BOOL log_datestamping; /* TRUE if logs are datestamped */ +extern int log_depth; /* depth of log tail window */ +extern uschar *log_display_buffer; /* to hold display text */ +extern uschar *log_file; /* supplied name of exim log file */ +extern uschar log_file_open[256]; /* actual open file */ +extern uschar *log_font; /* font for log display */ +extern ino_t log_inode; /* the inode of the log file */ +extern long int log_position; /* position in log file */ +extern int log_width; /* width of log tail window */ + +extern uschar *menu_event; /* name of menu event */ +extern int menu_is_up; /* TRUE when menu displayed */ +extern int min_height; /* min window height */ +extern int min_width; /* min window width */ + +extern pipe_item *pipe_chain; /* for delivery displays */ + +extern uschar *qualify_domain; +extern int queue_depth; /* depth of queue window */ +extern uschar *queue_font; /* font for queue display */ +extern int queue_max_addresses; /* limit on per-message list */ +extern skip_item *queue_skip; /* for hiding bits of queue */ +extern uschar *queue_stripchart_name; /* sic */ +extern int queue_update; /* update interval */ +extern int queue_width; /* width of queue window */ + +extern pcre *yyyymmdd_regex; /* for matching yyyy-mm-dd */ + +extern uschar *size_stripchart; /* path for size monitoring */ +extern uschar *size_stripchart_name; /* name for size stripchart */ +extern uschar *spool_directory; /* Name of exim spool directory */ +extern int spool_is_split; /* True if detected split spool */ +extern int start_small; /* True to start with small window */ +extern int stripchart_height; /* height of stripcharts */ +extern int stripchart_number; /* number of stripcharts */ +extern pcre **stripchart_regex; /* vector of regexps */ +extern uschar **stripchart_title; /* vector of titles */ +extern int *stripchart_total; /* vector of accumulating values */ +extern int stripchart_update; /* update interval */ +extern int stripchart_width; /* width of stripcharts */ +extern int stripchart_varstart; /* starting number for variable charts */ + +extern int text_depth; /* depth of text windows */ +extern int tick_queue_accumulator; /* For timing next auto update */ + +extern uschar *window_title; /* title of the exim monitor window */ + + +/************************************************* +* Global functions * +*************************************************/ + +extern XtActionProc dialogAction(Widget, XEvent *, String *, Cardinal *); + +extern uschar *copystring(uschar *); +extern void create_dialog(uschar *, uschar *); +extern void create_stripchart(Widget, uschar *); +extern void debug(char *, ...); +extern dest_item *find_dest(queue_item *, uschar *, int, BOOL); +extern queue_item *find_queue(uschar *, int, int); +extern void init(int, uschar **); +extern void menu_create(Widget, XEvent *, String *, Cardinal *); +extern void NonMessageDialogue(uschar *); +extern void queue_display(void); +extern void read_log(void); +extern int read_spool(uschar *); +extern int read_spool_init(uschar *); +extern void read_spool_tidy(void); +extern int repaint_window(StripChartWidget, int, int); +extern void scan_spool_input(int); +extern void stripchart_init(void); +extern void text_empty(Widget); +extern void text_show(Widget, uschar *); +extern void text_showf(Widget, char *, ...); +extern void xs_SetValues(Widget, Cardinal, ...); + +/* End of em_hdr.h */ diff --git a/exim_monitor/em_init.c b/exim_monitor/em_init.c new file mode 100644 index 0000000..56cb298 --- /dev/null +++ b/exim_monitor/em_init.c @@ -0,0 +1,237 @@ +/************************************************* +* Exim monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2009 */ +/* Copyright (c) The Exim Maintainers 2020 */ +/* See the file NOTICE for conditions of use and distribution. */ + +/* This module contains code to initialize things from the +environment and the arguments. */ + + +#include "em_hdr.h" + + + +/************************************************* +* Decode stripchart config * +*************************************************/ + +/* First determine how many are requested, then compile the +regular expressions and save the title strings. Note that +stripchart_number is initialized to 1 or 2 to count the always- +present queue stripchart, and the optional size-monitoring +stripchart. */ + +static void decode_stripchart_config(uschar *s) +{ +int i; + +/* Loop: first time just counts, second time does the +work. */ + +for (i = 0; i <= 1; i++) + + { + int first = 1; + int count = 0; + uschar *p = s; + + if (*p == '/') p++; /* allow optional / at start */ + + /* This loops for all the substrings, using the first flag + to determine whether each is the first or second of the pairs. */ + + while (*p) + { + uschar *pp; + /* Handle continuations */ + if (*p == '\n') + { + while (*(++p) == ' ' || *p == '\t'); + if (*p == '/') p++; + } + + /* Find the end of the string and count if first string */ + + pp = p; + while (*p && *p != '/') p++; + if (first) count++; + + /* Take action on the second time round. */ + + if (i != 0) + { + uschar buffer[256]; + int indx = count + stripchart_varstart - 1; + Ustrncpy(buffer, pp, p-pp); + buffer[p-pp] = 0; + if (first) + { + int offset; + const uschar *error; + if (!(stripchart_regex[indx] = pcre_compile(CS buffer, PCRE_COPT, + CCSS &error, &offset, NULL))) + { + printf("regular expression error: %s at offset %d " + "while compiling %s\n", error, offset, buffer); + exit(99); + } + } + else stripchart_title[indx] = string_copy(buffer); + } + + /* Advance past the delimiter and flip the first/second flag */ + + p++; + first = !first; + } + + /* On the first pass, we now know the number of stripcharts. Get + store for holding the pointers to the regular expressions and + title strings. */ + + if (i == 0) + { + stripchart_number += count; + stripchart_regex = (pcre **)store_malloc(stripchart_number * sizeof(pcre *)); + stripchart_title = (uschar **)store_malloc(stripchart_number * sizeof(uschar *)); + } + } +} + + +/************************************************* +* Initialize * +*************************************************/ + +void init(int argc, uschar **argv) +{ +int x; +int erroroffset; +uschar *s; +const uschar *error; + +argc = argc; /* These are currently unused. */ +argv = argv; + +/* Deal with simple values in the environment. */ + +s = US getenv("ACTION_OUTPUT"); +if (s != NULL) + { + if (Ustrcmp(s, "no") == 0) action_output = FALSE; + if (Ustrcmp(s, "yes") == 0) action_output = TRUE; + } + +s = US getenv("ACTION_QUEUE_UPDATE"); +if (s != NULL) + { + if (Ustrcmp(s, "no") == 0) action_queue_update = FALSE; + if (Ustrcmp(s, "yes") == 0) action_queue_update = TRUE; + } + +s = US getenv("BODY_MAX"); +if (s != NULL && (x = Uatoi(s)) != 0) body_max = x; + +s = US getenv("EXIM_PATH"); +if (s != NULL) exim_path = string_copy(s); + +s = US getenv("EXIMON_EXIM_CONFIG"); +if (s != NULL) alternate_config = string_copy(s); + +s = US getenv("LOG_BUFFER"); +if (s != NULL) + { + uschar c[1]; + if (sscanf(CS s, "%d%c", &x, c) > 0) + { + if (c[0] == 'K' || c[0] == 'k') x *= 1024; + if (x < 1024) x = 1024; + log_buffer_size = x; + } + } + +s = US getenv("LOG_DEPTH"); +if (s != NULL && (x = Uatoi(s)) != 0) log_depth = x; + +s = US getenv("LOG_FILE_NAME"); +if (s != NULL) log_file = string_copy(s); + +s = US getenv("LOG_FONT"); +if (s != NULL) log_font = string_copy(s); + +s = US getenv("LOG_WIDTH"); +if (s != NULL && (x = Uatoi(s)) != 0) log_width = x; + +s = US getenv("MENU_EVENT"); +if (s != NULL) menu_event = string_copy(s); + +s = US getenv("MIN_HEIGHT"); +if (s != NULL && (x = Uatoi(s)) > 0) min_height = x; + +s = US getenv("MIN_WIDTH"); +if (s != NULL && (x = Uatoi(s)) > 0) min_width = x; + +s = US getenv("QUALIFY_DOMAIN"); +if (s != NULL) qualify_domain = string_copy(s); + else qualify_domain = US""; /* Don't want NULL */ + +s = US getenv("QUEUE_DEPTH"); +if (s != NULL && (x = Uatoi(s)) != 0) queue_depth = x; + +s = US getenv("QUEUE_FONT"); +if (s != NULL) queue_font = string_copy(s); + +s = US getenv("QUEUE_INTERVAL"); +if (s != NULL && (x = Uatoi(s)) != 0) queue_update = x; + +s = US getenv("QUEUE_MAX_ADDRESSES"); +if (s != NULL && (x = Uatoi(s)) != 0) queue_max_addresses = x; + +s = US getenv("QUEUE_WIDTH"); +if (s != NULL && (x = Uatoi(s)) != 0) queue_width = x; + +s = US getenv("SPOOL_DIRECTORY"); +if (s != NULL) spool_directory = string_copy(s); + +s = US getenv("START_SMALL"); +if (s != NULL && Ustrcmp(s, "yes") == 0) start_small = 1; + +s = US getenv("TEXT_DEPTH"); +if (s != NULL && (x = Uatoi(s)) != 0) text_depth = x; + +s = US getenv("WINDOW_TITLE"); +if (s != NULL) window_title = string_copy(s); + +/* Deal with stripchart configuration. First see if we are monitoring +the size of a partition, then deal with log stripcharts in a separate +function */ + +s = US getenv("SIZE_STRIPCHART"); +if (s != NULL && *s != 0) + { + stripchart_number++; + stripchart_varstart++; + size_stripchart = string_copy(s); + s = US getenv("SIZE_STRIPCHART_NAME"); + if (s != NULL && *s != 0) size_stripchart_name = string_copy(s); + } + +s = US getenv("LOG_STRIPCHARTS"); +if (s != NULL) decode_stripchart_config(s); + +s = US getenv("STRIPCHART_INTERVAL"); +if (s != NULL && (x = Uatoi(s)) != 0) stripchart_update = x; + +s = US getenv("QUEUE_STRIPCHART_NAME"); +queue_stripchart_name = (s != NULL)? string_copy(s) : US"queue"; + +/* Compile the regex for matching yyyy-mm-dd at the start of a string. */ + +yyyymmdd_regex = pcre_compile("^\\d{4}-\\d\\d-\\d\\d\\s", PCRE_COPT, + CCSS &error, &erroroffset, NULL); +} + +/* End of em_init.c */ diff --git a/exim_monitor/em_log.c b/exim_monitor/em_log.c new file mode 100644 index 0000000..1e1dc7c --- /dev/null +++ b/exim_monitor/em_log.c @@ -0,0 +1,411 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2018 */ +/* See the file NOTICE for conditions of use and distribution. */ + +/* This module contains code for scanning the main log, +extracting information from it, and displaying a "tail". */ + +#include "em_hdr.h" + +#define log_buffer_len 4096 /* For each log entry */ + +/* If anonymizing, don't alter these strings (this is all an ad hoc hack). */ + +#ifdef ANONYMIZE +static char *oklist[] = { + "Completed", + "defer", + "from", + "Connection timed out", + "Start queue run: pid=", + "End queue run: pid=", + "host lookup did not complete", + "unexpected disconnection while reading SMTP command from", + "verify failed for SMTP recipient", + "H=", + "U=", + "id=", + "<", + ">", + "(", + ")", + "[", + "]", + "@", + "=", + "*", + ".", + "-", + "\"", + " ", + "\n"}; +static int oklist_size = sizeof(oklist) / sizeof(uschar *); +#endif + + + +/************************************************* +* Write to the log display * +*************************************************/ + +static int visible = 0; +static int scrolled = FALSE; +static int size = 0; +static int top = 0; + +static void show_log(char *s, ...) PRINTF_FUNCTION(1,2); + +static void show_log(char *s, ...) +{ +int length, newtop; +va_list ap; +XawTextBlock b; +uschar buffer[log_buffer_len + 24]; + +/* Do nothing if not tailing a log */ + +if (log_widget == NULL) return; + +/* Initialize the text block structure */ + +b.firstPos = 0; +b.ptr = CS buffer; +b.format = FMT8BIT; + +/* We want to know whether the window has been scrolled back or not, +so that we can cease automatically scrolling with new text. This turns +out to be tricky with the text widget. We can detect whether the +scroll bar has been operated by checking on the "top" value, but it's +harder to detect that it has been returned to the bottom. The following +heuristic does its best. */ + +newtop = XawTextTopPosition(log_widget); +if (newtop != top) + { + if (!scrolled) + { + visible = size - top; /* save size of window */ + scrolled = newtop < top; + } + else if (newtop > size - visible) scrolled = FALSE; + top = newtop; + } + +/* Format the text that is to be written. */ + +va_start(ap, s); +vsprintf(CS buffer, s, ap); +va_end(ap); +length = Ustrlen(buffer); + +/* If we are anonymizing for screen shots, flatten various things. */ + +#ifdef ANONYMIZE + { + uschar *p = buffer + 9; + if (p[6] == '-' && p[13] == '-') p += 17; + + while (p < buffer + length) + { + int i; + + /* Check for strings to be left alone */ + + for (i = 0; i < oklist_size; i++) + { + int len = Ustrlen(oklist[i]); + if (Ustrncmp(p, oklist[i], len) == 0) + { + p += len; + break; + } + } + if (i < oklist_size) continue; + + /* Leave driver names, size, protocol, alone */ + + if ((*p == 'D' || *p == 'P' || *p == 'T' || *p == 'S' || *p == 'R') && + p[1] == '=') + { + p += 2; + while (*p != ' ' && *p != 0) p++; + continue; + } + + /* Leave C= text alone */ + + if (Ustrncmp(p, "C=\"", 3) == 0) + { + p += 3; + while (*p != 0 && *p != '"') p++; + continue; + } + + /* Flatten remaining chars */ + + if (isdigit(*p)) *p++ = 'x'; + else if (isalpha(*p)) *p++ = 'x'; + else *p++ = '$'; + } + } +#endif + +/* If this would overflow the buffer, throw away 50% of the +current stuff in the buffer. Code defensively against odd +extreme cases that shouldn't actually arise. */ + +if (size + length > log_buffer_size) + { + if (size == 0) length = log_buffer_size/2; else + { + int cutcount = log_buffer_size/2; + if (cutcount > size) cutcount = size; else + { + while (cutcount < size && log_display_buffer[cutcount] != '\n') + cutcount++; + cutcount++; + } + b.length = 0; + XawTextReplace(log_widget, 0, cutcount, &b); + size -= cutcount; + top -= cutcount; + if (top < 0) top = 0; + if (top < cutcount) XawTextInvalidate(log_widget, 0, 999999); + xs_SetValues(log_widget, 1, "displayPosition", top); + } + } + +/* Insert the new text at the end of the buffer. */ + +b.length = length; +XawTextReplace(log_widget, 999999, 999999, &b); +size += length; + +/* When not scrolled back, we want to keep the bottom line +always visible. Put the insert point at the start of it because +this stops left/right scrolling with some X libraries. */ + +if (!scrolled) + { + XawTextSetInsertionPoint(log_widget, size - length); + top = XawTextTopPosition(log_widget); + } +} + + + + +/************************************************* +* Function to read the log * +*************************************************/ + +/* We read any new log entries, and use their data to +updated total counts for the configured stripcharts. +The count for the queue chart is handled separately. +We also munge the log entries and display a one-line +version in the log window. */ + +void read_log(void) +{ +struct stat statdata; +uschar buffer[log_buffer_len]; + +/* If log is not yet open, skip all of this. */ + +if (LOG != NULL) + { + if (fseek(LOG, log_position, SEEK_SET)) + { + perror("logfile fseek"); + exit(1); + } + + while (Ufgets(buffer, log_buffer_len, LOG) != NULL) + { + uschar *id; + uschar *p = buffer; + rmark reset_point; + int length = Ustrlen(buffer); + int i; + + /* Skip totally blank lines (paranoia: there shouldn't be any) */ + + while (*p == ' ' || *p == '\t') p++; + if (*p == '\n') continue; + + /* We should now have a complete log entry in the buffer; check + it for various regular expression matches and take appropriate + action. Get the current store point so we can reset to it. */ + + reset_point = store_mark(); + + /* First, update any stripchart data values, noting that the zeroth + stripchart is the queue length, which is handled elsewhere, and the + 1st may the a size monitor. */ + + for (i = stripchart_varstart; i < stripchart_number; i++) + { + if (pcre_exec(stripchart_regex[i], NULL, CS buffer, length, 0, PCRE_EOPT, + NULL, 0) >= 0) + stripchart_total[i]++; + } + + /* Munge the log entry and display shortened form on one line. + We omit the date and show only the time. Remove any time zone offset. + Take note of the presence of [pid]. */ + + if (pcre_exec(yyyymmdd_regex,NULL,CS buffer,length,0,PCRE_EOPT,NULL,0) >= 0) + { + int pidlength = 0; + if ((buffer[20] == '+' || buffer[20] == '-') && + isdigit(buffer[21]) && buffer[25] == ' ') + memmove(buffer + 20, buffer + 26, Ustrlen(buffer + 26) + 1); + if (buffer[20] == '[') + { + while (Ustrchr("[]0123456789", buffer[20+pidlength++]) != NULL); + } + id = string_copyn(buffer + 20 + pidlength, MESSAGE_ID_LENGTH); + show_log("%s", buffer+11); + } + else + { + id = US""; + show_log("%s", buffer); + } + + /* Deal with frozen and unfrozen messages */ + + if (strstric(buffer, US"frozen", FALSE) != NULL) + { + queue_item *qq = find_queue(id, queue_noop, 0); + if (qq) + qq->frozen = strstric(buffer, US"unfrozen", FALSE) == NULL; + } + + /* Notice defer messages, and add the destination if it + isn't already on the list for this message, with a pointer + to the parent if we can. */ + + if ((p = Ustrstr(buffer, "==")) != NULL) + { + queue_item *qq = find_queue(id, queue_noop, 0); + if (qq != NULL) + { + dest_item *d; + uschar *q, *r; + p += 2; + while (isspace(*p)) p++; + q = p; + while (*p != 0 && !isspace(*p)) + { + if (*p++ != '\"') continue; + while (*p != 0) + { + if (*p == '\\') p += 2; + else if (*p++ == '\"') break; + } + } + *p++ = 0; + if ((r = strstric(q, qualify_domain, FALSE)) != NULL && + *(--r) == '@') *r = 0; + + /* If we already have this destination, as tested case-insensitively, + do not add it to the destinations list. */ + + d = find_dest(qq, q, dest_add, TRUE); + + if (d->parent == NULL) + { + while (isspace(*p)) p++; + if (*p == '<') + { + dest_item *dd; + q = ++p; + while (*p != 0 && *p != '>') p++; + *p = 0; + if ((p = strstric(q, qualify_domain, FALSE)) != NULL && + *(--p) == '@') *p = 0; + dd = find_dest(qq, q, dest_noop, FALSE); + if (dd != NULL && dd != d) d->parent = dd; + } + } + } + } + + store_reset(reset_point); + } + } + + +/* We have to detect when the log file is changed, and switch to the new file. +In practice, for non-datestamped files, this means that some deliveries might +go unrecorded, since they'll be written to the old file, but this usually +happens in the middle of the night, and I don't think the hassle of keeping +track of two log files is worth it. + +First we check the datestamped name of the log file if necessary; if it is +different to the file we currently have open, go for the new file. As happens +in Exim itself, we leave in the following inode check, even when datestamping +because it does no harm and will cope should a file actually be renamed for +some reason. + +The test for a changed log file is to look up the inode of the file by name and +compare it with the saved inode of the file we currently are processing. This +accords with the usual interpretation of POSIX and other Unix specs that imply +"one file, one inode". However, it appears that on some Digital systems, if an +open file is unlinked, a new file may be created with the same inode while the +old file remains in existence. This can happen if the old log file is renamed, +processed in some way, and then deleted. To work round this, also test for a +link count of zero on the currently open file. */ + +if (log_datestamping) + { + uschar log_file_wanted[256]; + /* Do *not* use "%s" here, we need the %D datestamp in the log_file string to + be expanded. The trailing NULL arg is to quieten preprocessors that need at + least one arg for a variadic set in a macro. */ + string_format(log_file_wanted, sizeof(log_file_wanted), CS log_file, NULL); + if (Ustrcmp(log_file_wanted, log_file_open) != 0) + { + if (LOG != NULL) + { + fclose(LOG); + LOG = NULL; + } + Ustrcpy(log_file_open, log_file_wanted); + } + } + +if (LOG == NULL || + (fstat(fileno(LOG), &statdata) == 0 && statdata.st_nlink == 0) || + (Ustat(log_file, &statdata) == 0 && log_inode != statdata.st_ino)) + { + FILE *TEST; + + /* Experiment shows that sometimes you can't immediately open + the new log file - presumably immediately after the old one + is renamed and before the new one exists. Therefore do a + trial open first to be sure. */ + + if ((TEST = fopen(CS log_file_open, "r")) != NULL) + { + if (LOG != NULL) fclose(LOG); + LOG = TEST; + if (fstat(fileno(LOG), &statdata)) + { + fprintf(stderr, "fstat %s: %s\n", log_file_open, strerror(errno)); + exit(1); + } + log_inode = statdata.st_ino; + } + } + +/* Save the position we have got to in the log. */ + +if (LOG != NULL) log_position = ftell(LOG); +} + +/* End of em_log.c */ diff --git a/exim_monitor/em_main.c b/exim_monitor/em_main.c new file mode 100644 index 0000000..9c7f442 --- /dev/null +++ b/exim_monitor/em_main.c @@ -0,0 +1,944 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2018 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +#include "em_hdr.h" + +/* This module contains the main program of the Exim monitor, which +sets up the world and then lets the XtAppMainLoop function +run things off X events. */ + + +/************************************************* +* Static variables * +*************************************************/ + +/* Fallback resources */ + +static String fallback_resources[] = {"eximon.geometry: +150+0", NULL}; + +/* X11 fixed argument lists */ + +static Arg quit_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {XtNlabel, (XtArgVal) " Quit "}, + {"left", XawChainLeft}, + {"right", XawChainLeft}, + {"top", XawChainTop}, + {"bottom", XawChainTop} +}; + +static Arg resize_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {XtNfromHoriz,(XtArgVal) NULL}, /* must be second */ + {XtNlabel, (XtArgVal) " Size "}, + {"left", XawChainLeft}, + {"right", XawChainLeft}, + {"top", XawChainTop}, + {"bottom", XawChainTop} +}; + +static Arg update_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {XtNlabel, (XtArgVal) " Update "}, + {"left", XawChainLeft}, + {"right", XawChainLeft}, + {"top", XawChainTop}, + {"bottom", XawChainTop} +}; + +static Arg hide_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {XtNfromHoriz,(XtArgVal) NULL}, /* must be second */ + {XtNlabel, (XtArgVal) " Hide "}, + {"left", XawChainLeft}, + {"right", XawChainLeft}, + {"top", XawChainTop}, + {"bottom", XawChainTop} +}; + +static Arg unhide_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {XtNfromHoriz,(XtArgVal) NULL}, /* must be second */ + {XtNlabel, (XtArgVal) " Unhide "}, + {"left", XawChainLeft}, + {"right", XawChainLeft}, + {"top", XawChainTop}, + {"bottom", XawChainTop} +}; + +static Arg log_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {"editType", XawtextEdit}, + {"useStringInPlace", (XtArgVal)TRUE}, + {"string", (XtArgVal)""}, /* dummy to get it going */ + {"scrollVertical", XawtextScrollAlways}, + {"scrollHorizontal", XawtextScrollAlways}, + {"right", XawChainRight}, + {"top", XawChainTop}, + {"bottom", XawChainTop} +}; + +static Arg queue_args[] = { + {XtNfromVert, (XtArgVal) NULL}, /* must be first */ + {"editType", XawtextEdit}, + {"string", (XtArgVal)""}, /* dummy to get it going */ + {"scrollVertical", XawtextScrollAlways}, + {"right", XawChainRight}, + {"top", XawChainTop}, + {"bottom", XawChainBottom} +}; + +static Arg sizepos_args[] = { + {"width", (XtArgVal)NULL}, + {"height", (XtArgVal)NULL}, + {"x", (XtArgVal)NULL}, + {"y", (XtArgVal)NULL} +}; + +XtActionsRec menu_action_table[] = { + { "menu-create", menu_create } }; + +/* Types of non-message dialog action */ + +enum { da_hide }; + +/* Miscellaneous local variables */ + +static int dialog_action; +static int tick_stripchart_accumulator = 999999; +static int tick_interval = 2; +static int maxposset = 0; +static int minposset = 0; +static int x_adjustment = -1; +static int y_adjustment = -1; +static Dimension screenwidth, screenheight; +static Dimension original_x, original_y; +static Dimension maxposx, maxposy; +static Dimension minposx, minposy; +static Dimension maxwidth, maxheight; +static Widget outer_form_widget; +static Widget hide_widget; +static Widget above_queue_widget; + + + + +#ifdef STRERROR_FROM_ERRLIST +/************************************************* +* Provide strerror() for non-ANSI libraries * +*************************************************/ + +/* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror() +in their libraries, but can provide the same facility by this simple +alternative function. */ + +uschar * +strerror(int n) +{ +if (n < 0 || n >= sys_nerr) return "unknown error number"; +return sys_errlist[n]; +} +#endif /* STRERROR_FROM_ERRLIST */ + + + +/************************************************* +* Handle attempts to write the log * +*************************************************/ + +/* The message gets written to stderr when log_write() is called from a +utility. The message always gets '\n' added on the end of it. These calls come +from modules such as store.c when things go drastically wrong (e.g. malloc() +failing). In normal use they won't get obeyed. + +Arguments: + selector not relevant when running a utility + flags not relevant when running a utility + format a printf() format + ... arguments for format + +Returns: nothing +*/ + +void +log_write(unsigned int selector, int flags, const char *format, ...) +{ +va_list ap; +va_start(ap, format); +vfprintf(stderr, format, ap); +fprintf(stderr, "\n"); +va_end(ap); +selector = selector; /* Keep picky compilers happy */ +flags = flags; +} + + + + +/************************************************* +* Extract port from address string * +*************************************************/ + +/* In the spool file, a host plus port is given as an IP address followed by a +dot and a port number. This function decodes this. It is needed by the +spool-reading function, and copied here to avoid having to include the whole +host.c module. One day the interaction between exim and eximon with regard to +included code MUST be tidied up! + +Argument: + address points to the string; if there is a port, the '.' in the string + is overwritten with zero to terminate the address + +Returns: 0 if there is no port, else the port number. +*/ + +int +host_address_extract_port(uschar *address) +{ +int skip = -3; /* Skip 3 dots in IPv4 addresses */ +address--; +while (*(++address) != 0) + { + int ch = *address; + if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */ + else if (ch == '.' && skip++ >= 0) break; + } +if (*address == 0) return 0; +*address++ = 0; +return Uatoi(address); +} + + + + +/************************************************* +* SIGCHLD handler * +*************************************************/ + +/* Operations on messages are done in subprocesses; this handler +just catches them when they finish. It causes a queue display update +unless configured not to. */ + +static void sigchld_handler(int sig) +{ +while (waitpid(-1, NULL, WNOHANG) > 0); +signal(sig, sigchld_handler); +if (action_queue_update) tick_queue_accumulator = 999999; +} + + + +/************************************************* +* Callback routines * +*************************************************/ + + +void updateAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +client_data = client_data; +call_data = call_data; +scan_spool_input(TRUE); +queue_display(); +tick_queue_accumulator = 0; +} + +void hideAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +client_data = client_data; +call_data = call_data; +actioned_message[0] = 0; +dialog_ref_widget = w; +dialog_action = da_hide; +create_dialog(US"Hide addresses ending with", US""); +} + +void unhideAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +skip_item *sk = queue_skip; + +w = w; /* Keep picky compilers happy */ +client_data = client_data; +call_data = call_data; + +while (sk != NULL) + { + skip_item *next = sk->next; + store_free(sk); + sk = next; + } +queue_skip = NULL; + +XtDestroyWidget(unhide_widget); +unhide_widget = NULL; + +scan_spool_input(TRUE); +queue_display(); +tick_queue_accumulator = 0; +} + +void quitAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +client_data = client_data; +call_data = call_data; +exit(0); +} + + +/* Action when the "Size" button is pressed. This is a kludged up mess +that I made work after much messing around. Reading the position of the +toplevel widget gets the absolute position of the data portion of the window, +excluding the window manager's furniture. However, positioning the toplevel +widget's window seems to position the top corner of the furniture under the twm +window manager, but not under fwvm and others. The two cases are distinguished +by the values of x_adjustment and y_adjustment. + +For twm (adjustment >= 0), one has to fudge the miminizing function to ensure +that we go back to exactly the same position as before. + +For fwvm (adjustment < 0), one has to fudge the "top left hand corner" +positioning to ensure that the window manager's furniture gets displayed on the +screen. I haven't found a way of discovering the thickness of the furniture, so +some screwed-in values are used. + +This is all ad hoc, developed by floundering around as I haven't found any +documentation that tells me what I really should do. */ + +void resizeAction(Widget button, XtPointer client_data, XtPointer call_data) +{ +Dimension x, y; +Dimension width, height; +XWindowAttributes a; +Window w = XtWindow(toplevel_widget); + +button = button; /* Keep picky compilers happy */ +client_data = client_data; +call_data = call_data; + +/* Get the position and size of the top level widget. */ + +sizepos_args[0].value = (XtArgVal)(&width); +sizepos_args[1].value = (XtArgVal)(&height); +sizepos_args[2].value = (XtArgVal)(&x); +sizepos_args[3].value = (XtArgVal)(&y); +XtGetValues(toplevel_widget, sizepos_args, 4); + +/* Get the position of the widget's window relative to its parent; this +gives the thickness of the window manager's furniture. At least it does +in twm. For fwvm it gives zero. The size/movement function uses this data. +I tried doing this before entering the main loop, but it didn't always +work properly with twm. Running it every time seems to be OK. */ + +XGetWindowAttributes(X_display, XtWindow(toplevel_widget), &a); +if (a.x != 0) x_adjustment = a.x; +if (a.y != 0) y_adjustment = a.y; + +/* If at maximum size, reduce to minimum and move back to where it was +when maximized, if that value is set, allowing for the furniture in cases +where the positioning includes the furniture. */ + +if (width == maxwidth && height == maxheight) + { + maxposx = x; + maxposy = y; + maxposset = 1; + + if (minposset) + xs_SetValues(toplevel_widget, 4, + "width", min_width, + "height", min_height, + "x", minposx - ((x_adjustment >= 0)? x_adjustment : 0), + "y", minposy - ((y_adjustment >= 0)? y_adjustment : 0)); + else + xs_SetValues(toplevel_widget, 2, + "width", min_width, + "height", min_height); + } + +/* Else always expand to maximum. If currently at minimum size, remember where +it was for coming back. If we don't have a value for the thickness of the +furniture, the implication is that the coordinates position the application +window, so we can't use (0,0) because that loses the furniture. Use screwed in +values that seem to work with fvwm. */ + +else + { + int xx = x; + int yy = y; + + if (width == min_width && height == min_height) + { + minposx = x; + minposy = y; + minposset = 1; + } + + if ((int)(x + maxwidth) > (int)screenwidth || + (int)(y + maxheight + 10) > (int)screenheight) + { + if (maxposset) + { + xx = maxposx - ((x_adjustment >= 0)? x_adjustment : 0); + yy = maxposy - ((y_adjustment >= 0)? y_adjustment : 0); + } + else + { + if ((int)(x + maxwidth) > (int)screenwidth) + xx = (x_adjustment >= 0)? 0 : 4; + if ((int)(y + maxheight + 10) > (int)screenheight) + yy = (y_adjustment >= 0)? 0 : 21; + } + + xs_SetValues(toplevel_widget, 4, + "width", maxwidth, + "height", maxheight, + "x", xx, + "y", yy); + } + + else xs_SetValues(toplevel_widget, 2, + "width", maxwidth, + "height", maxheight); + } + +/* Ensure the window is at the top */ + +XRaiseWindow(X_display, w); +} + + + + +/************************************************* +* Handle input from non-msg dialogue * +*************************************************/ + +/* The various cases here are: hide domain, (no more yet) */ + +void NonMessageDialogue(uschar *s) +{ +skip_item *sk; + +switch(dialog_action) + { + case da_hide: + + /* Create the unhide button if not present */ + + if (unhide_widget == NULL) + { + unhide_args[0].value = (XtArgVal) above_queue_widget; + unhide_args[1].value = (XtArgVal) hide_widget; + unhide_widget = XtCreateManagedWidget("unhide", commandWidgetClass, + outer_form_widget, unhide_args, XtNumber(unhide_args)); + XtAddCallback(unhide_widget, "callback", unhideAction, NULL); + } + + /* Add item to skip queue */ + + sk = (skip_item *)store_malloc(sizeof(skip_item) + Ustrlen(s)); + sk->next = queue_skip; + queue_skip = sk; + Ustrcpy(sk->text, s); + sk->reveal = time(NULL) + 60 * 60; + scan_spool_input(TRUE); + queue_display(); + tick_queue_accumulator = 0; + break; + } +} + + + +/************************************************* +* Ticker function * +*************************************************/ + +/* This function is called initially to set up the starting data +values; it then sets a timeout so that it continues to be called +every 2 seconds. */ + +static void ticker(XtPointer pt, XtIntervalId *i) +{ +pipe_item **pp = &pipe_chain; +pipe_item *p = pipe_chain; +tick_queue_accumulator += tick_interval; +tick_stripchart_accumulator += tick_interval; +read_log(); + +pt = pt; /* Keep picky compilers happy */ +i = i; + +/* If we have passed the queue update time, we must do a full +scan of the queue, checking for new arrivals, etc. This will +as a by-product set the count of items for use by the stripchart +display. On some systems, SIGCHLD signals can get lost at busy times, +so just in case, clean up any completed children here. */ + +if (tick_queue_accumulator >= queue_update) + { + scan_spool_input(TRUE); + queue_display(); + tick_queue_accumulator = 0; + if (tick_stripchart_accumulator >= stripchart_update) + tick_stripchart_accumulator = 0; + while (waitpid(-1, NULL, WNOHANG) > 0); + } + +/* Otherwise, if we have exceeded the stripchart interval, +do a reduced queue scan that simply provides the count for +the stripchart. */ + +else if (tick_stripchart_accumulator >= stripchart_update) + { + scan_spool_input(FALSE); + tick_stripchart_accumulator = 0; + } + +/* Scan any pipes that are set up for listening to delivery processes, +and display their output if their windows are still open. */ + +while (p != NULL) + { + int count; + uschar buffer[256]; + + while ((count = read(p->fd, buffer, 254)) > 0) + { + buffer[count] = 0; + if (p->widget != NULL) text_show(p->widget, buffer); + } + + if (count == 0) + { + close(p->fd); + *pp = p->next; + store_free(p); + /* If configured, cause display update */ + if (action_queue_update) tick_queue_accumulator = 999999; + } + + else pp = &(p->next); + + p = *pp; + } + +/* Reset the timer for next time */ + +XtAppAddTimeOut(X_appcon, tick_interval * 1000, ticker, 0); +} + + + +/************************************************* +* Find Num Lock modifiers * +*************************************************/ + +/* Return a string with the modifiers generated by XK_Num_Lock, or return +NULL if XK_Num_Lock doesn't generate any modifiers. This is needed because Num +Lock isn't always the same modifier on all servers. + +Arguments: + display the Display + buf a buffer in which to put the answers (long enough to hold 5) + +Returns: points to the buffer, or NULL +*/ + +static uschar * +numlock_modifiers(Display *display, uschar *buf) +{ +XModifierKeymap *m; +int i, j; +uschar *ret = NULL; + +m = XGetModifierMapping(display); +if (m == NULL) + { + printf("Not enough memory\n"); + exit (EXIT_FAILURE); + } + +/* Look at Mod1 through Mod5, and fill in the buffer as necessary. */ + +buf[0] = 0; +for (i = 3; i < 8; i++) + { + for (j = 0; j < m->max_keypermod; j++) + { + if (XKeycodeToKeysym(display, m->modifiermap [i*m->max_keypermod + j], 0) + == XK_Num_Lock) + { + sprintf(CS(buf+Ustrlen(buf)), " Mod%d", i-2); + ret = buf; + } + } + } + +XFreeModifiermap(m); +return ret; +} + + + +/************************************************* +* Initialize * +*************************************************/ + +int main(int argc, char **argv) +{ +int i; +struct stat statdata; +uschar modbuf[] = " Mod1 Mod2 Mod3 Mod4 Mod5"; +uschar *numlock; +Widget stripchart_form_widget, + update_widget, + quit_widget, + resize_widget; + +/* The exim global message_id needs to get set */ + +message_id_external = message_id_option + 1; +message_id = message_id_external + 1; +message_subdir[1] = 0; + +/* Some store needs getting for big_buffer, which is used for +constructing file names and things. This call will initialize +the store_get() function. */ + +big_buffer = store_get(big_buffer_size, FALSE); + +/* Set up the version string and date and output them */ + +version_init(); +printf("\nExim Monitor version %s (compiled %s) initializing\n", + version_string, version_date); + +/* Initialize various things from the environment and arguments. */ + +init(argc, USS argv); + +/* Set up the SIGCHLD handler */ + +signal(SIGCHLD, sigchld_handler); + +/* Get the buffer for storing the string for the log display. */ + +log_display_buffer = US store_malloc(log_buffer_size); +log_display_buffer[0] = 0; + +/* Initialize the data structures for the stripcharts */ + +stripchart_init(); + +/* If log_file contains the empty string, then Exim is running using syslog +only, and we can't tail the log. If not, open the log file and position to the +end of it. Before doing so, we have to detect whether the log files are +datestamped, and if so, sort out the name. The string in log_file already has +%s replaced by "main"; if datestamping is occurring, %D or %M will be present. +In fact, we don't need to test explicitly - just process the string with +string_format. + +Once opened, save the file's inode so that we can detect when the file is +switched to another one for non-datestamped files. However, allow the monitor +to start up without a log file (can happen if no messages have been sent +today.) */ + +if (log_file[0] != 0) + { + /* Do *not* use "%s" here, we need the %D datestamp in the log_file to + be expanded! */ + (void)string_format(log_file_open, sizeof(log_file_open), CS log_file, NULL); + log_datestamping = string_datestamp_offset >= 0; + + LOG = fopen(CS log_file_open, "r"); + + if (LOG == NULL) + { + printf("*** eximon warning: can't open log file %s - will try " + "periodically\n", log_file_open); + } + else + { + fseek(LOG, 0, SEEK_END); + log_position = ftell(LOG); + if (fstat(fileno(LOG), &statdata)) + { + perror("log file fstat"); + fclose(LOG); + LOG=NULL; + } + else + log_inode = statdata.st_ino; + } + } +else + { + printf("*** eximon warning: no log file available to tail\n"); + } + +/* Now initialize the X world and create the top-level widget */ + +toplevel_widget = XtAppInitialize(&X_appcon, "Eximon", NULL, 0, &argc, argv, + fallback_resources, NULL, 0); +X_display = XtDisplay(toplevel_widget); +xs_SetValues(toplevel_widget, 4, + "title", window_title, + "iconName", window_title, + "minWidth", min_width, + "minHeight", min_height); + + +/* Create the action for setting up the menu in the queue display +window, and register the action for positioning the menu. */ + +XtAppAddActions(X_appcon, menu_action_table, 1); +XawSimpleMenuAddGlobalActions(X_appcon); + +/* Set up translation tables for the text widgets we use. We don't +want all the generality of editing, etc. that the defaults provide. +This cannot be done before initializing X - the parser complains +about unknown events, modifiers, etc. in an unhelpful way... The +queue text widget has a different table which includes the button +for popping up the menu. Note that the order of things in these +tables is significant. Shift<thing> must come before <thing> as +otherwise it isn't noticed. */ + +/* + <FocusIn>: display-caret(on)\n\ + <FocusOut>: display-caret(off)\n\ +*/ + +/* The translation manager sets up passive grabs for the menu popups as a +result of MenuPopup(), but the grabs match only the exact modifiers listed, +hence combinations with and without caps-lock and num-lock must be given, +rather than just one "Shift<Btn1Down>" (or whatever menu_event is set to), +despite the fact that that notation (without a leading !) should ignore the +state of other modifiers. Thanks to Kevin Ryde for this information, and for +the function above that discovers which modifier is Num Lock, because it turns +out that it varies from server to server. */ + +sprintf(CS big_buffer, + "!%s: menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\ + !Lock %s: menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\ + ", menu_event, menu_event); + +numlock = numlock_modifiers(X_display, modbuf); /* Get Num Lock modifier(s) */ + +if (numlock != NULL) sprintf(CS big_buffer + Ustrlen(big_buffer), + "!%s %s: menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\ + !Lock %s %s: menu-create() XawPositionSimpleMenu(menu) MenuPopup(menu)\n\ + ", numlock, menu_event, numlock, menu_event); + +sprintf(CS big_buffer + Ustrlen(big_buffer), + "<Btn1Down>: select-start()\n\ + <Btn1Motion>: extend-adjust()\n\ + <Btn1Up>: extend-end(PRIMARY,CUT_BUFFER0)\n\ + <Btn3Down>: extend-start()\n\ + <Btn3Motion>: extend-adjust()\n\ + <Btn3Up>: extend-end(PRIMARY,CUT_BUFFER0)\n\ + <Key>Up: scroll-one-line-down()\n\ + <Key>Down: scroll-one-line-up()\n\ + Ctrl<Key>R: search(backward)\n\ + Ctrl<Key>S: search(forward)\n\ + "); + +queue_trans = XtParseTranslationTable(CS big_buffer); + +text_trans = XtParseTranslationTable( + "<Btn1Down>: select-start()\n\ + <Btn1Motion>: extend-adjust()\n\ + <Btn1Up>: extend-end(PRIMARY,CUT_BUFFER0)\n\ + <Btn3Down>: extend-start()\n\ + <Btn3Motion>: extend-adjust()\n\ + <Btn3Up>: extend-end(PRIMARY,CUT_BUFFER0)\n\ + <Key>Up: scroll-one-line-down()\n\ + <Key>Down: scroll-one-line-up()\n\ + Ctrl<Key>R: search(backward)\n\ + Ctrl<Key>S: search(forward)\n\ + "); + + +/* Create a toplevel form widget to hold all the other things */ + +outer_form_widget = XtCreateManagedWidget("form", formWidgetClass, + toplevel_widget, NULL, 0); + +/* Now create an inner form to hold the stripcharts */ + +stripchart_form_widget = XtCreateManagedWidget("form", formWidgetClass, + outer_form_widget, NULL, 0); +xs_SetValues(stripchart_form_widget, 5, + "defaultDistance", 8, + "left", XawChainLeft, + "right", XawChainLeft, + "top", XawChainTop, + "bottom", XawChainTop); + +/* Create the queue count stripchart and its label. */ + +create_stripchart(stripchart_form_widget, queue_stripchart_name); + +/* If configured, create the size monitoring stripchart, but +only if the OS supports statfs(). */ + +if (size_stripchart != NULL) + { +#ifdef HAVE_STATFS + if (size_stripchart_name == NULL) + { + size_stripchart_name = size_stripchart + Ustrlen(size_stripchart) - 1; + while (size_stripchart_name > size_stripchart && + *size_stripchart_name == '/') size_stripchart_name--; + while (size_stripchart_name > size_stripchart && + *size_stripchart_name != '/') size_stripchart_name--; + } + create_stripchart(stripchart_form_widget, size_stripchart_name); +#else + printf("Can't create size stripchart: statfs() function not available\n"); +#endif + } + +/* Now create the configured input/output stripcharts; note +the total number includes the queue stripchart. */ + +for (i = stripchart_varstart; i < stripchart_number; i++) + create_stripchart(stripchart_form_widget, stripchart_title[i]); + +/* Next in vertical order come the Resize & Quit buttons */ + +quit_args[0].value = (XtArgVal) stripchart_form_widget; +quit_widget = XtCreateManagedWidget("quit", commandWidgetClass, + outer_form_widget, quit_args, XtNumber(quit_args)); +XtAddCallback(quit_widget, "callback", quitAction, NULL); + +resize_args[0].value = (XtArgVal) stripchart_form_widget; +resize_args[1].value = (XtArgVal) quit_widget; +resize_widget = XtCreateManagedWidget("resize", commandWidgetClass, + outer_form_widget, resize_args, XtNumber(resize_args)); +XtAddCallback(resize_widget, "callback", resizeAction, NULL); + +/* In the absence of log tailing, the quit widget is the one above the +queue listing. */ + +above_queue_widget = quit_widget; + +/* Create an Ascii text widget for the log tail display if we are tailing a +log. Skip it if not. */ + +if (log_file[0] != 0) + { + log_args[0].value = (XtArgVal) quit_widget; + log_widget = XtCreateManagedWidget("log", asciiTextWidgetClass, + outer_form_widget, log_args, XtNumber(log_args)); + XawTextDisplayCaret(log_widget, TRUE); + xs_SetValues(log_widget, 6, + "editType", XawtextEdit, + "translations", text_trans, + "string", log_display_buffer, + "length", log_buffer_size, + "height", log_depth, + "width", log_width); + + if (log_font != NULL) + { + XFontStruct *f = XLoadQueryFont(X_display, CS log_font); + if (f != NULL) xs_SetValues(log_widget, 1, "font", f); + } + + above_queue_widget = log_widget; + } + +/* The update button */ + +update_args[0].value = (XtArgVal) above_queue_widget; +update_widget = XtCreateManagedWidget("update", commandWidgetClass, + outer_form_widget, update_args, XtNumber(update_args)); +XtAddCallback(update_widget, "callback", updateAction, NULL); + +/* The hide button */ + +hide_args[0].value = (XtArgVal) above_queue_widget; +hide_args[1].value = (XtArgVal) update_widget; +hide_widget = XtCreateManagedWidget("hide", commandWidgetClass, + outer_form_widget, hide_args, XtNumber(hide_args)); +XtAddCallback(hide_widget, "callback", hideAction, NULL); + +/* Create an Ascii text widget for the queue display. */ + +queue_args[0].value = (XtArgVal) update_widget; +queue_widget = XtCreateManagedWidget("queue", asciiTextWidgetClass, + outer_form_widget, queue_args, XtNumber(queue_args)); +XawTextDisplayCaret(queue_widget, TRUE); + +xs_SetValues(queue_widget, 4, + "editType", XawtextEdit, + "height", queue_depth, + "width", queue_width, + "translations", queue_trans); + +if (queue_font != NULL) + { + XFontStruct *f = XLoadQueryFont(X_display, CS queue_font); + if (f != NULL) xs_SetValues(queue_widget, 1, "font", f); + } + +/* Call the ticker function to get the initial data set up. It +arranges to have itself recalled every 2 seconds. */ + +ticker(NULL, NULL); + +/* Everything is now set up; this flag is used by the regerror +function and also by the queue reader. */ + +eximon_initialized = TRUE; +printf("\nExim Monitor running\n"); + +/* Realize the toplevel and thereby get things displayed */ + +XtRealizeWidget(toplevel_widget); + +/* Find out the size of the initial window, and set that as its +maximum. While we are at it, get the initial position. */ + +sizepos_args[0].value = (XtArgVal)(&maxwidth); +sizepos_args[1].value = (XtArgVal)(&maxheight); +sizepos_args[2].value = (XtArgVal)(&original_x); +sizepos_args[3].value = (XtArgVal)(&original_y); +XtGetValues(toplevel_widget, sizepos_args, 4); + +xs_SetValues(toplevel_widget, 2, + "maxWidth", maxwidth, + "maxHeight", maxheight); + +/* Set up the size of the screen */ + +screenwidth = XDisplayWidth(X_display, 0); +screenheight= XDisplayHeight(X_display,0); + +/* Register the action table */ + +XtAppAddActions(X_appcon, actionTable, actionTableSize); + +/* Reduce the window to the small size if this is wanted */ + +if (start_small) resizeAction(NULL, NULL, NULL); + +/* Enter the application loop which handles things from here +onwards. The return statement is never obeyed, but is needed to +keep pedantic ANSI compilers happy. */ + +XtAppMainLoop(X_appcon); + +return 0; +} + +/* End of em_main.c */ + diff --git a/exim_monitor/em_menu.c b/exim_monitor/em_menu.c new file mode 100644 index 0000000..2a70a18 --- /dev/null +++ b/exim_monitor/em_menu.c @@ -0,0 +1,994 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2018 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +#include "em_hdr.h" + +/* This module contains code for handling the popup menus. */ + +static Widget menushell; +static Widget queue_text_sink; +static Widget dialog_shell, dialog_widget; + +static Widget text_create(uschar *, int); + +static int highlighted_start, highlighted_end, highlighted_x, highlighted_y; + + + +static Arg queue_get_arg[] = { + { "textSink", (XtArgVal)NULL }, + { "textSource", (XtArgVal)NULL }, + { "string", (XtArgVal)NULL } }; + +static Arg dialog_arg[] = { + { "label", (XtArgVal)"dialog" }, + { "value", (XtArgVal)"value" } }; + +static Arg get_pos_args[] = { + {"x", (XtArgVal)NULL }, + {"y", (XtArgVal)NULL } }; + +static Arg menushell_arg[] = { + { "label", (XtArgVal)NULL } }; + +static Arg button_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { XtNlabel, (XtArgVal) " Dismiss " }, + { "left", XawChainLeft }, + { "right", XawChainLeft }, + { "top", XawChainBottom }, + { "bottom", XawChainBottom } }; + +static Arg text_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "editType", XawtextEdit }, + { "string", (XtArgVal)"" }, /* dummy to get it going */ + { "scrollVertical", XawtextScrollAlways }, + { "wrap", XawtextWrapWord }, + { "top", XawChainTop }, + { "bottom", XawChainBottom } }; + +static Arg item_1_arg[] = { + { XtNfromVert, (XtArgVal)NULL }, /* must be first */ + { "label", (XtArgVal)" Message log" } }; + +static Arg item_2_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Headers" } }; + +static Arg item_3_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Body" } }; + +static Arg item_4_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Deliver message" } }; + +static Arg item_5_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Freeze message" } }; + +static Arg item_6_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Thaw message" } }; + +static Arg item_7_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Give up on msg" } }; + +static Arg item_8_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Remove message" } }; + +static Arg item_9_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)"----------------" } }; + +static Arg item_10_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Add recipient" } }; + +static Arg item_11_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Mark delivered" } }; + +static Arg item_12_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Mark all delivered" } }; + +static Arg item_13_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" Edit sender" } }; + +static Arg item_99_arg[] = { + { XtNfromVert, (XtArgVal) NULL }, /* must be first */ + { "label", (XtArgVal)" " } }; + + + +/************************************************* +* Destroy the menu when popped down * +*************************************************/ + +static void popdownAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +client_data = client_data; /* Keep picky compilers happy */ +call_data = call_data; +if (highlighted_x >= 0) + XawTextSinkDisplayText(queue_text_sink, + highlighted_x, highlighted_y, + highlighted_start, highlighted_end, 0); +XtDestroyWidget(w); +menu_is_up = FALSE; +} + + + +/************************************************* +* Display the message log * +*************************************************/ + +static void +msglogAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +int i; +Widget text = text_create(US client_data, text_depth); +uschar * fname = NULL; +FILE * f = NULL; + +w = w; /* Keep picky compilers happy */ +call_data = call_data; + +/* End up with the split version, so message looks right when non-exist */ + +for (i = 0; i < (spool_is_split ? 2:1); i++) + { + message_subdir[0] = i != 0 ? (US client_data)[5] : 0; + fname = spool_fname(US"msglog", message_subdir, US client_data, US""); + if ((f = fopen(CS fname, "r"))) + break; + } + +if (!f) + text_showf(text, "%s: %s\n", fname, strerror(errno)); +else + { + uschar buffer[256]; + while (Ufgets(buffer, sizeof(buffer), f) != NULL) text_show(text, buffer); + fclose(f); + } +} + + + +/************************************************* +* Display the message body * +*************************************************/ + +static void +bodyAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +int i; +Widget text = text_create(US client_data, text_depth); +FILE *f = NULL; + +w = w; /* Keep picky compilers happy */ +call_data = call_data; + +for (i = 0; i < (spool_is_split? 2:1); i++) + { + uschar * fname; + message_subdir[0] = i != 0 ? (US client_data)[5] : 0; + fname = spool_fname(US"input", message_subdir, US client_data, US"-D"); + if ((f = fopen(CS fname, "r"))) + break; + } + +if (f == NULL) + text_showf(text, "Failed to open file: %s\n", strerror(errno)); +else + { + uschar buffer[256]; + int count = 0; + + while (Ufgets(buffer, sizeof(buffer), f) != NULL) + { + text_show(text, buffer); + count += Ustrlen(buffer); + if (count > body_max) + { + text_show(text, US"\n*** Message length exceeds BODY_MAX ***\n"); + break; + } + } + fclose(f); + } +} + + + +/************************************************* +* Do something to a message * +*************************************************/ + +/* The output is not shown in a window for non-delivery actions that succeed, +unless action_output is set. We can't, however, tell until we have run +the command whether we want the output or not, so the pipe has to be set up in +all cases. */ + +static void ActOnMessage(uschar *id, uschar *action, uschar *address_arg) +{ +int pid; +int pipe_fd[2]; +int delivery = Ustrcmp(action + Ustrlen(action) - 2, "-M") == 0; +uschar *quote = US""; +uschar *at = US""; +uschar *qualify = US""; +uschar buffer[256]; +queue_item *qq; +Widget text = NULL; + +/* If the address arg is not empty and does not contain @ and there is a +qualify domain, qualify it. (But don't qualify '<>'.)*/ + +if (address_arg[0] != 0) + { + quote = US"\'"; + if (Ustrchr(address_arg, '@') == NULL && + Ustrcmp(address_arg, "<>") != 0 && + qualify_domain != NULL && + qualify_domain[0] != 0) + { + at = US"@"; + qualify = qualify_domain; + } + } +sprintf(CS buffer, "%s %s %s %s %s %s%s%s%s%s", exim_path, + (alternate_config == NULL)? US"" : US"-C", + (alternate_config == NULL)? US"" : alternate_config, + action, id, quote, address_arg, at, qualify, quote); + +/* If we know we are going to need the window, create it now. */ + +if (action_output || delivery) + { + text = text_create(id, text_depth); + text_showf(text, "%s\n", buffer); + } + +/* Create the pipe for output. Remember, on most systems pipe[0] is +for reading and pipe[1] is for writing! Solaris, with its two-way +pipes is a trap! */ + +if (pipe(pipe_fd) != 0) + { + if (text == NULL) + { + text = text_create(id, text_depth); + text_showf(text, "%s\n", buffer); + } + text_show(text, US"*** Failed to create pipe ***\n"); + return; + } + +if ( fcntl(pipe_fd[0], F_SETFL, O_NONBLOCK) + || fcntl(pipe_fd[1], F_SETFL, O_NONBLOCK)) + { + perror("set nonblocking on pipe"); + exit(1); + } + +/* Delivering a message can take some time, and we want to show the +output as it goes along. This requires subprocesses and is coded below. For +other commands, we can assume an immediate response, and so need not waste +resources with subprocesses. If action_output is FALSE, don't show the +output at all. */ + +if (!delivery) + { + int count, rc; + int save_stdout = dup(1); + int save_stderr = dup(2); + + close(1); + close(2); + + dup2(pipe_fd[1], 1); + dup2(pipe_fd[1], 2); + close(pipe_fd[1]); + + rc = system(CS buffer); + + close(1); + close(2); + + if (action_output || rc != 0) + { + if (text == NULL) + { + text = text_create(id, text_depth); + text_showf(text, "%s\n", buffer); + } + while ((count = read(pipe_fd[0], buffer, 254)) > 0) + { + buffer[count] = 0; + text_show(text, buffer); + } + } + + close(pipe_fd[0]); + + dup2(save_stdout, 1); + dup2(save_stderr, 2); + close(save_stdout); + close(save_stderr); + + /* If action was to change the sender, and it succeeded, we have to + update the in-store data. */ + + if (rc == 0 && Ustrcmp(action + Ustrlen(action) - 4, "-Mes") == 0) + { + queue_item *q = find_queue(id, queue_noop, 0); + if (q) + { + if (q->sender) store_free(q->sender); + q->sender = store_malloc(Ustrlen(address_arg) + 1); + Ustrcpy(q->sender, address_arg); + } + } + + /* If configured, cause a display update and return */ + + if (action_queue_update) tick_queue_accumulator = 999999; + return; + } + +/* Message is to be delivered. Ensure that it is marked unfrozen, +because nothing will get written to the log to show that this has +happened. (Other freezing/unfreezings get logged and picked up from +there.) */ + +qq = find_queue(id, queue_noop, 0); +if (qq != NULL) qq->frozen = FALSE; + +/* New, asynchronous code runs in a subprocess for commands that +will take some time. The main process does not wait. There is a +SIGCHLD handler in the main program that cleans up any terminating +sub processes. */ + +if ((pid = fork()) == 0) + { + close(1); + close(2); + + dup2(pipe_fd[1], 1); + dup2(pipe_fd[1], 2); + close(pipe_fd[1]); + + system(CS buffer); + + close(1); + close(2); + close(pipe_fd[0]); + _exit(0); + } + +/* Main process - set up an item for the main ticker to watch. */ + +if (pid < 0) text_showf(text, "Failed to fork: %s\n", strerror(errno)); else + { + pipe_item *p = (pipe_item *)store_malloc(sizeof(pipe_item)); + + if (p == NULL) + { + text_show(text, US"Run out of store\n"); + return; + } + + p->widget = text; + p->fd = pipe_fd[0]; + + p->next = pipe_chain; + pipe_chain = p; + + close(pipe_fd[1]); + } +} + + + + +/************************************************* +* Cause a message to be delivered * +*************************************************/ + +static void deliverAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +ActOnMessage(US client_data, US"-v -M", US""); +} + + + +/************************************************* +* Cause a message to be Frozen * +*************************************************/ + +static void freezeAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +ActOnMessage(US client_data, US"-Mf", US""); +} + + + +/************************************************* +* Cause a message to be thawed * +*************************************************/ + +static void thawAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +ActOnMessage(US client_data, US"-Mt", US""); +} + + + +/************************************************* +* Take action using dialog data * +*************************************************/ + +/* This function is called after a dialog box has been filled +in. It is global because it is set up in the action table at +start-up time. If the string is empty, do nothing. */ + +XtActionProc dialogAction(Widget w, XEvent *event, String *ss, Cardinal *c) +{ +uschar *s = US XawDialogGetValueString(dialog_widget); + +w = w; /* Keep picky compilers happy */ +event = event; +ss = ss; +c = c; + +XtPopdown((Widget)dialog_shell); +XtDestroyWidget((Widget)dialog_shell); +while (isspace(*s)) s++; +if (s[0] != 0) + { + if (actioned_message[0] != 0) + ActOnMessage(actioned_message, action_required, s); + else + NonMessageDialogue(s); /* When called from somewhere else */ + } +return NULL; +} + + + +/************************************************* +* Create a dialog box * +*************************************************/ + +/* The focus is grabbed exclusively, so nothing else can +be done to the application until the box is filled in. This +function is also used by the Hide button handler. */ + +void create_dialog(uschar *label, uschar *value) +{ +Arg warg[4]; +Dimension x, y, xx, yy; +XtTranslations pop_trans; +Widget text; + +/* Get the position of a reference widget so the dialog box can be put +near to it. */ + +get_pos_args[0].value = (XtArgVal)(&x); +get_pos_args[1].value = (XtArgVal)(&y); +XtGetValues(dialog_ref_widget, get_pos_args, 2); + +/* When this is not a message_specific thing, the position of the reference +widget is relative to the window. Get the position of the top level widget and +add to the position. */ + +if (dialog_ref_widget != menushell) + { + get_pos_args[0].value = (XtArgVal)(&xx); + get_pos_args[1].value = (XtArgVal)(&yy); + XtGetValues(toplevel_widget, get_pos_args, 2); + x += xx; + y += yy; + } + +/* Create a transient shell for the dialog box. */ + +XtSetArg(warg[0], XtNtransientFor, queue_widget); +XtSetArg(warg[1], XtNx, x + 50); +XtSetArg(warg[2], XtNy, y + 50); +XtSetArg(warg[3], XtNallowShellResize, True); +dialog_shell = XtCreatePopupShell("forDialog", transientShellWidgetClass, + toplevel_widget, warg, 4); + +/* Create the dialog box. */ + +dialog_arg[0].value = (XtArgVal)label; +dialog_arg[1].value = (XtArgVal)value; +dialog_widget = XtCreateManagedWidget("dialog", dialogWidgetClass, dialog_shell, + dialog_arg, XtNumber(dialog_arg)); + +/* Get the text widget from within the dialog box, give it the keyboard focus, +make it wider than the default, and override its translations to make Return +call the dialog action function. */ + +text = XtNameToWidget(dialog_widget, "value"); +XawTextSetInsertionPoint(text, Ustrlen(value)); +XtSetKeyboardFocus(dialog_widget, text); +xs_SetValues(text, 1, "width", 200); +pop_trans = XtParseTranslationTable( + "<Key>Return: dialogAction()\n"); +XtOverrideTranslations(text, pop_trans); + +/* Pop the thing up. */ + +XtPopup(dialog_shell, XtGrabExclusive); +XFlush(X_display); +} + + + + + +/************************************************* +* Cause a recipient to be added * +*************************************************/ + +/* This just sets up the dialog box; the action happens when it has been filled +in. */ + +static void addrecipAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +Ustrncpy(actioned_message, client_data, 24); +actioned_message[23] = '\0'; +action_required = US"-Mar"; +dialog_ref_widget = menushell; +create_dialog(US"Recipient address to add?", US""); +} + + + +/************************************************* +* Cause an address to be marked delivered * +*************************************************/ + +static void markdelAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +Ustrncpy(actioned_message, client_data, 24); +actioned_message[23] = '\0'; +action_required = US"-Mmd"; +dialog_ref_widget = menushell; +create_dialog(US"Recipient address to mark delivered?", US""); +} + + +/************************************************* +* Cause all addresses to be marked delivered * +*************************************************/ + +static void markalldelAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +ActOnMessage(US client_data, US"-Mmad", US""); +} + + +/************************************************* +* Edit the message's sender * +*************************************************/ + +static void editsenderAction(Widget w, XtPointer client_data, + XtPointer call_data) +{ +queue_item *q; +uschar *sender; +w = w; /* Keep picky compilers happy */ +call_data = call_data; +Ustrncpy(actioned_message, client_data, 24); +actioned_message[23] = '\0'; +q = find_queue(actioned_message, queue_noop, 0); +sender = !q ? US"" : q->sender[0] == 0 ? US"<>" : q->sender; +action_required = US"-Mes"; +dialog_ref_widget = menushell; +create_dialog(US"New sender address?", sender); +} + + +/************************************************* +* Cause a message to be returned to sender * +*************************************************/ + +static void giveupAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +ActOnMessage(US client_data, US"-v -Mg", US""); +} + + + +/************************************************* +* Cause a message to be cancelled * +*************************************************/ + +static void removeAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +w = w; /* Keep picky compilers happy */ +call_data = call_data; +ActOnMessage(US client_data, US"-Mrm", US""); +} + + + +/************************************************* +* Display a message's headers * +*************************************************/ + +static void headersAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +uschar buffer[256]; +header_line *h, *next; +Widget text = text_create(US client_data, text_depth); +rmark reset_point; + +w = w; /* Keep picky compilers happy */ +call_data = call_data; + +/* Remember the point in the dynamic store so we can recover to it afterwards. +Then use Exim's function to read the header. */ + +reset_point = store_mark(); + +sprintf(CS buffer, "%s-H", US client_data); +if (spool_read_header(buffer, TRUE, FALSE) != spool_read_OK) + { + if (errno == ERRNO_SPOOLFORMAT) + { + struct stat statbuf; + sprintf(CS big_buffer, "%s/input/%s", spool_directory, buffer); + if (Ustat(big_buffer, &statbuf) == 0) + text_showf(text, "Format error in spool file %s: size=%lu\n", buffer, + (unsigned long)statbuf.st_size); + else text_showf(text, "Format error in spool file %s\n", buffer); + } + else text_showf(text, "Read error for spool file %s\n", buffer); + store_reset(reset_point); + return; + } + +if (sender_address != NULL) + { + text_showf(text, "%s sender: <%s>\n", f.sender_local ? "Local" : "Remote", + sender_address); + } + +if (recipients_list != NULL) + { + int i; + text_show(text, US"Recipients:\n"); + for (i = 0; i < recipients_count; i++) + { + text_showf(text, " %s %s\n", + (tree_search(tree_nonrecipients, recipients_list[i].address) == NULL)? + " ":"*", recipients_list[i].address); + } + text_show(text, US"\n"); + } + +for (h = header_list; h != NULL; h = next) + { + next = h->next; + text_showf(text, "%c ", h->type); /* Don't push h->text through a %s */ + text_show(text, h->text); /* expansion as it may be v large */ + } + +store_reset(reset_point); +} + + + + +/************************************************* +* Dismiss a text window * +*************************************************/ + +static void dismissAction(Widget w, XtPointer client_data, XtPointer call_data) +{ +pipe_item *p = pipe_chain; + +w = w; /* Keep picky compilers happy */ +call_data = call_data; + +XtPopdown((Widget)client_data); +XtDestroyWidget((Widget)client_data); + +/* If this is a text widget for a sub-process, clear it out of +the chain so that subsequent data doesn't try to use it. We have +to search the parents of the saved widget to see if one of them +is what we have just destroyed. */ + +while (p != NULL) + { + Widget pp = p->widget; + while (pp != NULL) + { + if (pp == (Widget)client_data) { p->widget = NULL; return; } + pp = XtParent(pp); + } + p = p->next; + } +} + + + +/************************************************* +* Set up popup text window * +*************************************************/ + +static Widget text_create(uschar *name, int height) +{ +Widget textshell, form, text, button; + +/* Create a popup shell widget to display as an additional +toplevel window. */ + +textshell = XtCreatePopupShell("textshell", topLevelShellWidgetClass, + toplevel_widget, NULL, 0); +xs_SetValues(textshell, 4, + "title", name, + "iconName", name, + "minWidth", 100, + "minHeight", 100); + +/* Create a form widget, containing the text widget and the +dismiss button widget. */ + +form = XtCreateManagedWidget("textform", formWidgetClass, + textshell, NULL, 0); +xs_SetValues(form, 1, "defaultDistance", 8); + +text = XtCreateManagedWidget("texttext", asciiTextWidgetClass, + form, text_arg, XtNumber(text_arg)); +xs_SetValues(text, 4, + "editType", XawtextAppend, + "width", 700, + "height", height, + "translations", text_trans); +XawTextDisplayCaret(text, TRUE); + +/* Use the same font as for the queue display */ + +if (queue_font != NULL) + { + XFontStruct *f = XLoadQueryFont(X_display, CS queue_font); + if (f != NULL) xs_SetValues(text, 1, "font", f); + } + +button_arg[0].value = (XtArgVal)text; +button = XtCreateManagedWidget("dismiss", commandWidgetClass, + form, button_arg, XtNumber(button_arg)); +XtAddCallback(button, "callback", dismissAction, (XtPointer)textshell); + +/* Get the toplevel popup displayed, and yield the text widget so +that text can be put into it. */ + +XtPopup(textshell, XtGrabNone); +return text; +} + + + + +/************************************************* +* Set up menu in queue window * +*************************************************/ + +/* We have added an action table that causes this function to +be called, and set up button 2 in the text widgets to call it. */ + +void menu_create(Widget w, XEvent *event, String *actargs, Cardinal *count) +{ +int line; +int i; +uschar *s; +XawTextPosition p; +Widget src, menu_line, item_1, item_2, item_3, item_4, + item_5, item_6, item_7, item_8, item_9, item_10, item_11, + item_12, item_13; +XtTranslations menu_trans = XtParseTranslationTable( + "<EnterWindow>: highlight()\n\ + <LeaveWindow>: unhighlight()\n\ + <BtnMotion>: highlight()\n\ + <BtnUp>: MenuPopdown()notify()unhighlight()\n\ + "); + +actargs = actargs; /* Keep picky compilers happy */ +count = count; + +/* Get the sink and source and the current text pointer */ + +queue_get_arg[0].value = (XtArgVal)(&queue_text_sink); +queue_get_arg[1].value = (XtArgVal)(&src); +queue_get_arg[2].value = (XtArgVal)(&s); +XtGetValues(w, queue_get_arg, 3); + +/* Find the line number of the pointer in the window, and the +character offset of the top lefthand of the window. */ + +line = (event->xbutton).y / XawTextSinkMaxHeight(queue_text_sink, 1); +p = XawTextTopPosition(w); + +/* Find the start of the line on which the button was clicked. */ + +i = line; +while (i-- > 0) + { + while (s[p] != 0 && s[p++] != '\n'); + } + +/* Now pointing either at 0 or 1st uschar after \n, or very 1st uschar. +If 0, the click was beyond the end of the data; just set up a dummy +menu. (Not easy to ignore as several actions are specified for the +mouse click and it expects this one to set up a menu.) If on a +continuation line, move back to the main line. */ + +if (s[p] == 0) + { + menushell_arg[0].value = (XtArgVal)"No message selected"; + menushell = XtCreatePopupShell("menu", simpleMenuWidgetClass, + queue_widget, menushell_arg, XtNumber(menushell_arg)); + XtAddCallback(menushell, "popdownCallback", popdownAction, NULL); + xs_SetValues(menushell, 2, + "cursor", XCreateFontCursor(X_display, XC_arrow), + "translations", menu_trans); + + /* To keep the widgets in XFree86 happy, we have to create at least one menu + item, it seems. (Openwindows doesn't mind a menu with no items.) Otherwise + there's a complaint about a zero width menu, and a crash. */ + + menu_line = XtCreateManagedWidget("line", smeLineObjectClass, menushell, + NULL, 0); + + item_99_arg[0].value = (XtArgVal)menu_line; + (void)XtCreateManagedWidget("item99", smeBSBObjectClass, menushell, + item_99_arg, XtNumber(item_99_arg)); + + highlighted_x = -1; + return; + } + +while (p > 0 && s[p+11] == ' ') + { + line--; + p--; + while (p > 0 && s[p-1] != '\n') p--; + } + +/* Now pointing at first character of a main line. */ + +Ustrncpy(message_id, s+p+11, MESSAGE_ID_LENGTH); +message_id[MESSAGE_ID_LENGTH] = 0; + +/* Highlight the line being menued, and save its parameters so that it +can be de-highlighted at popdown. */ + +highlighted_start = highlighted_end = p; +while (s[highlighted_end] != '\n') highlighted_end++; +highlighted_x = 17; +highlighted_y = line * XawTextSinkMaxHeight(queue_text_sink, 1) + 2; + +XawTextSinkDisplayText(queue_text_sink, + highlighted_x, highlighted_y, + highlighted_start, highlighted_end, 1); + +/* Create the popup shell and the other widgets that comprise the menu. +Set the translations and pointer shape, and add the callback pointers. */ + +menushell_arg[0].value = (XtArgVal)message_id; +menushell = XtCreatePopupShell("menu", simpleMenuWidgetClass, + queue_widget, menushell_arg, XtNumber(menushell_arg)); +XtAddCallback(menushell, "popdownCallback", popdownAction, NULL); + +xs_SetValues(menushell, 2, + "cursor", XCreateFontCursor(X_display, XC_arrow), + "translations", menu_trans); + +menu_line = XtCreateManagedWidget("line", smeLineObjectClass, menushell, + NULL, 0); + +item_1_arg[0].value = (XtArgVal)menu_line; +item_1 = XtCreateManagedWidget("item1", smeBSBObjectClass, menushell, + item_1_arg, XtNumber(item_1_arg)); +XtAddCallback(item_1, "callback", msglogAction, (XtPointer)message_id); + +item_2_arg[0].value = (XtArgVal)item_1; +item_2 = XtCreateManagedWidget("item2", smeBSBObjectClass, menushell, + item_2_arg, XtNumber(item_2_arg)); +XtAddCallback(item_2, "callback", headersAction, (XtPointer)message_id); + +item_3_arg[0].value = (XtArgVal)item_2; +item_3 = XtCreateManagedWidget("item3", smeBSBObjectClass, menushell, + item_3_arg, XtNumber(item_3_arg)); +XtAddCallback(item_3, "callback", bodyAction, (XtPointer)message_id); + +item_4_arg[0].value = (XtArgVal)item_3; +item_4 = XtCreateManagedWidget("item4", smeBSBObjectClass, menushell, + item_4_arg, XtNumber(item_4_arg)); +XtAddCallback(item_4, "callback", deliverAction, (XtPointer)message_id); + +item_5_arg[0].value = (XtArgVal)item_4; +item_5 = XtCreateManagedWidget("item5", smeBSBObjectClass, menushell, + item_5_arg, XtNumber(item_5_arg)); +XtAddCallback(item_5, "callback", freezeAction, (XtPointer)message_id); + +item_6_arg[0].value = (XtArgVal)item_5; +item_6 = XtCreateManagedWidget("item6", smeBSBObjectClass, menushell, + item_6_arg, XtNumber(item_6_arg)); +XtAddCallback(item_6, "callback", thawAction, (XtPointer)message_id); + +item_7_arg[0].value = (XtArgVal)item_6; +item_7 = XtCreateManagedWidget("item7", smeBSBObjectClass, menushell, + item_7_arg, XtNumber(item_7_arg)); +XtAddCallback(item_7, "callback", giveupAction, (XtPointer)message_id); + +item_8_arg[0].value = (XtArgVal)item_7; +item_8 = XtCreateManagedWidget("item8", smeBSBObjectClass, menushell, + item_8_arg, XtNumber(item_8_arg)); +XtAddCallback(item_8, "callback", removeAction, (XtPointer)message_id); + +item_9_arg[0].value = (XtArgVal)item_8; +item_9 = XtCreateManagedWidget("item9", smeBSBObjectClass, menushell, + item_9_arg, XtNumber(item_9_arg)); + +item_10_arg[0].value = (XtArgVal)item_9; +item_10 = XtCreateManagedWidget("item10", smeBSBObjectClass, menushell, + item_10_arg, XtNumber(item_10_arg)); +XtAddCallback(item_10, "callback", addrecipAction, (XtPointer)message_id); + +item_11_arg[0].value = (XtArgVal)item_10; +item_11 = XtCreateManagedWidget("item11", smeBSBObjectClass, menushell, + item_11_arg, XtNumber(item_11_arg)); +XtAddCallback(item_11, "callback", markdelAction, (XtPointer)message_id); + +item_12_arg[0].value = (XtArgVal)item_11; +item_12 = XtCreateManagedWidget("item12", smeBSBObjectClass, menushell, + item_12_arg, XtNumber(item_12_arg)); +XtAddCallback(item_12, "callback", markalldelAction, (XtPointer)message_id); + +item_13_arg[0].value = (XtArgVal)item_12; +item_13 = XtCreateManagedWidget("item13", smeBSBObjectClass, menushell, + item_13_arg, XtNumber(item_13_arg)); +XtAddCallback(item_13, "callback", editsenderAction, (XtPointer)message_id); + +/* Arrange that the menu pops up with the first item selected. */ + +xs_SetValues(menushell, 1, "popupOnEntry", item_1); + +/* Flag that the menu is up to suppress queue updates. */ + +menu_is_up = TRUE; +} + +/* End of em_menu.c */ diff --git a/exim_monitor/em_queue.c b/exim_monitor/em_queue.c new file mode 100644 index 0000000..2146fcb --- /dev/null +++ b/exim_monitor/em_queue.c @@ -0,0 +1,828 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2018 */ +/* Copyright (c) The Exim Maintainers 2020 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +#include "em_hdr.h" + + +/* This module contains functions to do with scanning exim's +queue and displaying the data therefrom. */ + + +/* If we are anonymizing for screen shots, define a function to anonymize +addresses. Otherwise, define a macro that does nothing. */ + +#ifdef ANONYMIZE +static uschar *anon(uschar *s) +{ +static uschar anon_result[256]; +uschar *ss = anon_result; +for (; *s != 0; s++) *ss++ = (*s == '@' || *s == '.')? *s : 'x'; +*ss = 0; +return anon_result; +} +#else +#define anon(x) x +#endif + + +/************************************************* +* Static variables * +*************************************************/ + +static int queue_total = 0; /* number of items in queue */ + +/* Table for turning base-62 numbers into binary */ + +static uschar tab62[] = + {0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0-9 */ + 0,10,11,12,13,14,15,16,17,18,19,20, /* A-K */ + 21,22,23,24,25,26,27,28,29,30,31,32, /* L-W */ + 33,34,35, 0, 0, 0, 0, 0, /* X-Z */ + 0,36,37,38,39,40,41,42,43,44,45,46, /* a-k */ + 47,48,49,50,51,52,53,54,55,56,57,58, /* l-w */ + 59,60,61}; /* x-z */ + +/* Index for quickly finding things in the ordered queue. */ + +static queue_item *queue_index[queue_index_size]; + + + +/************************************************* +* Find/Create/Delete a destination * +*************************************************/ + +/* If the action is dest_noop, then just return item or NULL; +if it is dest_add, then add if not present, and return item; +if it is dest_remove, remove if present and return NULL. The +address is lowercased to start with, unless it begins with +"*", which it does for error messages. */ + +dest_item * +find_dest(queue_item *q, uschar *name, int action, BOOL caseless) +{ +dest_item *dd; +dest_item **d = &(q->destinations); + +while (*d != NULL) + { + if ((caseless? strcmpic(name,(*d)->address) : Ustrcmp(name,(*d)->address)) + == 0) + { + dest_item *ddd; + + if (action != dest_remove) return *d; + dd = *d; + *d = dd->next; + store_free(dd); + + /* Unset any parent pointers that were to this address */ + + for (ddd = q->destinations; ddd != NULL; ddd = ddd->next) + { + if (ddd->parent == dd) ddd->parent = NULL; + } + + return NULL; + } + d = &((*d)->next); + } + +if (action != dest_add) return NULL; + +dd = (dest_item *)store_malloc(sizeof(dest_item) + Ustrlen(name)); +Ustrcpy(dd->address, name); +dd->next = NULL; +dd->parent = NULL; +*d = dd; +return dd; +} + + + +/************************************************* +* Clean up a dead queue item * +*************************************************/ + +static void +clean_up(queue_item *p) +{ +dest_item *dd = p->destinations; +while (dd != NULL) + { + dest_item *next = dd->next; + store_free(dd); + dd = next; + } +if (p->sender != NULL) store_free(p->sender); +store_free(p); +} + + +/************************************************* +* Set up an ACL variable * +*************************************************/ + +/* The spool_read_header() function calls acl_var_create() when it reads in an +ACL variable. We know that in this case, the variable will be new, not re-used, +so this is a cut-down version, to save including the whole acl.c module (which +would need conditional compilation to cut most of it out). */ + +tree_node * +acl_var_create(uschar *name) +{ +tree_node *node, **root; +root = (name[0] == 'c')? &acl_var_c : &acl_var_m; +node = store_get(sizeof(tree_node) + Ustrlen(name), FALSE); +Ustrcpy(node->name, name); +node->data.ptr = NULL; +(void)tree_insertnode(root, node); +return node; +} + + + +/************************************************* +* Set up new queue item * +*************************************************/ + +static queue_item * +set_up(uschar *name, int dir_char) +{ +int i, rc, save_errno; +struct stat statdata; +rmark reset_point; +uschar *p; +queue_item *q = (queue_item *)store_malloc(sizeof(queue_item)); +uschar buffer[256]; + +/* Initialize the block */ + +q->next = q->prev = NULL; +q->destinations = NULL; +Ustrncpy(q->name, name, sizeof(q->name)); +q->seen = TRUE; +q->frozen = FALSE; +q->dir_char = dir_char; +q->sender = NULL; +q->size = 0; + +/* Read the header file from the spool; if there is a failure it might mean +inaccessibility as a result of protections. A successful read will have caused +sender_address to get set and the recipients fields to be initialized. If +there's a format error in the headers, we can still display info from the +envelope. + +Before reading the header remember the position in the dynamic store so that +we can recover the store into which the header is read. All data read by +spool_read_header that is to be preserved is copied into malloc store. */ + +reset_point = store_mark(); +message_size = 0; +message_subdir[0] = dir_char; +sprintf(CS buffer, "%s-H", name); +rc = spool_read_header(buffer, FALSE, TRUE); +save_errno = errno; + +/* If we failed to read the envelope, compute the input time by +interpreting the id as a base-62 number. */ + +if (rc != spool_read_OK && rc != spool_read_hdrerror) + { + int t = 0; + for (i = 0; i < 6; i++) t = t * 62 + tab62[name[i] - '0']; + q->update_time = q->input_time = t; + } + +/* Envelope read; get input time and remove qualify_domain from sender address, +if it's there. */ + +else + { + q->update_time = q->input_time = received_time.tv_sec; + if ((p = strstric(sender_address+1, qualify_domain, FALSE)) != NULL && + *(--p) == '@') *p = 0; + } + +/* If we didn't read the whole header successfully, generate an error +message. If the envelope was read, this appears as a first recipient; +otherwise it sets set up in the sender field. */ + +if (rc != spool_read_OK) + { + uschar *msg; + + if (save_errno == ERRNO_SPOOLFORMAT) + { + struct stat statbuf; + sprintf(CS big_buffer, "%s/input/%s", spool_directory, buffer); + if (Ustat(big_buffer, &statbuf) == 0) + msg = string_sprintf("*** Format error in spool file: size = " OFF_T_FMT " ***", + statbuf.st_size); + else msg = US"*** Format error in spool file ***"; + } + else msg = US"*** Cannot read spool file ***"; + + if (rc == spool_read_hdrerror) + { + (void)find_dest(q, msg, dest_add, FALSE); + } + else + { + f.deliver_freeze = FALSE; + sender_address = msg; + recipients_count = 0; + } + } + +/* Now set up the remaining data. */ + +q->frozen = f.deliver_freeze; + +if (f.sender_set_untrusted) + { + if (sender_address[0] == 0) + { + q->sender = store_malloc(Ustrlen(originator_login) + 6); + sprintf(CS q->sender, "<> (%s)", originator_login); + } + else + { + q->sender = store_malloc(Ustrlen(sender_address) + + Ustrlen(originator_login) + 4); + sprintf(CS q->sender, "%s (%s)", sender_address, originator_login); + } + } +else + { + q->sender = store_malloc(Ustrlen(sender_address) + 1); + Ustrcpy(q->sender, sender_address); + } + +sender_address = NULL; + +snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s-D", + spool_directory, queue_name, message_subdir, name); +if (Ustat(buffer, &statdata) == 0) + q->size = message_size + statdata.st_size - SPOOL_DATA_START_OFFSET + 1; + +/* Scan and process the recipients list, skipping any that have already +been delivered, and removing visible names. */ + +if (recipients_list != NULL) + for (i = 0; i < recipients_count; i++) + { + uschar *r = recipients_list[i].address; + if (tree_search(tree_nonrecipients, r) == NULL) + { + if ((p = strstric(r+1, qualify_domain, FALSE)) != NULL && + *(--p) == '@') *p = 0; + (void)find_dest(q, r, dest_add, FALSE); + } + } + +/* Recover the dynamic store used by spool_read_header(). */ + +store_reset(reset_point); +return q; +} + + + +/************************************************* +* Find/Create a queue item * +*************************************************/ + +/* The queue is kept as a doubly-linked list, sorted by name. However, +to speed up searches, an index into the list is used. This is maintained +by the scan_spool_input function when it goes down the list throwing +out entries that are no longer needed. When the action is "add" and +we don't need to add, mark the found item as seen. */ + + +#ifdef never +static void debug_queue(void) +{ +int i; +int count = 0; +queue_item *p; +printf("\nqueue_total=%d\n", queue_total); + +for (i = 0; i < queue_index_size; i++) + printf("index %d = %d %s\n", i, (int)(queue_index[i]), + (queue_index[i])->name); + +printf("Queue is:\n"); +p = queue_index[0]; +while (p != NULL) + { + count++; + for (i = 0; i < queue_index_size; i++) + { + if (queue_index[i] == p) printf("count=%d index=%d\n", count, (int)p); + } + printf("%d %d %d %s\n", (int)p, (int)p->next, (int)p->prev, p->name); + p = p->next; + } +} +#endif + + + +queue_item * +find_queue(uschar *name, int action, int dir_char) +{ +int first = 0; +int last = queue_index_size - 1; +int middle = (first + last)/2; +queue_item *p, *q, *qq; + +/* Handle the empty queue as a special case. */ + +if (queue_total == 0) + { + if (action != queue_add) return NULL; + if ((qq = set_up(name, dir_char)) != NULL) + { + int i; + for (i = 0; i < queue_index_size; i++) queue_index[i] = qq; + queue_total++; + return qq; + } + return NULL; + } + +/* Also handle insertion at the start or end of the queue +as special cases. */ + +if (Ustrcmp(name, (queue_index[0])->name) < 0) + { + if (action != queue_add) return NULL; + if ((qq = set_up(name, dir_char)) != NULL) + { + qq->next = queue_index[0]; + (queue_index[0])->prev = qq; + queue_index[0] = qq; + queue_total++; + return qq; + } + return NULL; + } + +if (Ustrcmp(name, (queue_index[queue_index_size-1])->name) > 0) + { + if (action != queue_add) return NULL; + if ((qq = set_up(name, dir_char)) != NULL) + { + qq->prev = queue_index[queue_index_size-1]; + (queue_index[queue_index_size-1])->next = qq; + queue_index[queue_index_size-1] = qq; + queue_total++; + return qq; + } + return NULL; + } + +/* Use binary chopping on the index to get a range of the queue to search +when the name is somewhere in the middle, if present. */ + +while (middle > first) + { + if (Ustrcmp(name, (queue_index[middle])->name) >= 0) first = middle; + else last = middle; + middle = (first + last)/2; + } + +/* Now search down the part of the queue in which the item must +lie if it exists. Both end points are inclusive - though in fact +the bottom one can only be = if it is the original bottom. */ + +p = queue_index[first]; +q = queue_index[last]; + +for (;;) + { + int c = Ustrcmp(name, p->name); + + /* Already on queue; mark seen if required. */ + + if (c == 0) + { + if (action == queue_add) p->seen = TRUE; + return p; + } + + /* Not on the queue; add an entry if required. Note that set-up might + fail (the file might vanish under our feet). Note also that we know + there is always a previous item to p because the end points are + inclusive. */ + + else if (c < 0) + { + if (action == queue_add) + { + if ((qq = set_up(name, dir_char)) != NULL) + { + qq->next = p; + qq->prev = p->prev; + p->prev->next = qq; + p->prev = qq; + queue_total++; + return qq; + } + } + return NULL; + } + + /* Control should not reach here if p == q, because the name + is supposed to be <= the name of the bottom item. */ + + if (p == q) return NULL; + + /* Else might be further down the queue; continue */ + + p = p->next; + } + +/* Control should never reach here. */ +} + + + +/************************************************* +* Scan the exim spool directory * +*************************************************/ + +/* If we discover that there are subdirectories, set a flag so that the menu +code knows to look for them. We count the entries to set the value for the +queue stripchart, and set up data for the queue display window if the "full" +option is given. */ + +void +scan_spool_input(int full) +{ +int i; +int subptr; +int subdir_max = 1; +int count = 0; +int indexptr = 1; +queue_item *p; +uschar input_dir[256]; +uschar subdirs[64]; + +subdirs[0] = 0; +stripchart_total[0] = 0; + +sprintf(CS input_dir, "%s/input", spool_directory); +subptr = Ustrlen(input_dir); +input_dir[subptr+2] = 0; /* terminator for lengthened name */ + +/* Loop for each spool file on the queue - searching any subdirectories that +may exist. When initializing eximon, every file will have to be read. To show +there is progress, output a dot for each one to the standard output. */ + +for (i = 0; i < subdir_max; i++) + { + int subdirchar = subdirs[i]; /* 0 for main directory */ + DIR *dd; + struct dirent *ent; + + if (subdirchar != 0) + { + input_dir[subptr] = '/'; + input_dir[subptr+1] = subdirchar; + } + + if (!(dd = exim_opendir(input_dir))) continue; + + while ((ent = readdir(dd))) + { + uschar *name = US ent->d_name; + int len = Ustrlen(name); + + /* If we find a single alphameric sub-directory on the first + pass, add it to the list for subsequent scans, and remember that + we are dealing with a split directory. */ + + if (i == 0 && len == 1 && isalnum(*name)) + { + subdirs[subdir_max++] = *name; + spool_is_split = TRUE; + continue; + } + + /* Otherwise, if it is a header spool file, add it to the list */ + + if (len == SPOOL_NAME_LENGTH && + name[SPOOL_NAME_LENGTH - 2] == '-' && + name[SPOOL_NAME_LENGTH - 1] == 'H') + { + uschar basename[SPOOL_NAME_LENGTH + 1]; + stripchart_total[0]++; + if (!eximon_initialized) { printf("."); fflush(stdout); } + Ustrcpy(basename, name); + basename[SPOOL_NAME_LENGTH - 2] = 0; + if (full) find_queue(basename, queue_add, subdirchar); + } + } + closedir(dd); + } + +/* If simply counting the number, we are done; same if there are no +items in the in-store queue. */ + +if (!full || queue_total == 0) return; + +/* Now scan the queue and remove any items that were not in the directory. At +the same time, set up the index pointers into the queue. Because we are +removing items, the total that we are comparing against isn't actually correct, +but in a long queue it won't make much difference, and in a short queue it +doesn't matter anyway!*/ + +for (p = queue_index[0]; p; ) + if (!p->seen) + { + queue_item * next = p->next; + if (p->prev) + p->prev->next = next; + else + queue_index[0] = next; + if (next) + next->prev = p->prev; + else + { + int i; + queue_item * q = queue_index[queue_index_size-1]; + for (i = queue_index_size - 1; i >= 0; i--) + if (queue_index[i] == q) queue_index[i] = p->prev; + } + clean_up(p); + queue_total--; + p = next; + } + else + { + if (++count > (queue_total * indexptr)/(queue_index_size-1)) + queue_index[indexptr++] = p; + p->seen = FALSE; /* for next time */ + p = p->next; + } + +/* If a lot of messages have been removed at the bottom, we may not +have got the index all filled in yet. Make sure all the pointers +are legal. */ + +while (indexptr < queue_index_size - 1) + queue_index[indexptr++] = queue_index[queue_index_size-1]; +} + + + + +/************************************************* +* Update the recipients list for a message * +*************************************************/ + +/* We read the spool file only if its update time differs from last time, +or if there is a journal file in existence. */ + +/* First, a local subroutine to scan the non-recipients tree and +remove any of them from the address list */ + +static void +scan_tree(queue_item *p, tree_node *tn) +{ +if (tn != NULL) + { + if (tn->left != NULL) scan_tree(p, tn->left); + if (tn->right != NULL) scan_tree(p, tn->right); + (void)find_dest(p, tn->name, dest_remove, FALSE); + } +} + +/* The main function */ + +static void update_recipients(queue_item *p) +{ +int i; +FILE *jread; +rmark reset_point; +struct stat statdata; +uschar buffer[1024]; + +message_subdir[0] = p->dir_char; + +snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s-J", + spool_directory, queue_name, message_subdir, p->name); + +if (!(jread = fopen(CS buffer, "r"))) + { + snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s-H", + spool_directory, queue_name, message_subdir, p->name); + if (Ustat(buffer, &statdata) < 0 || p->update_time == statdata.st_mtime) + return; + } + +/* Get the contents of the header file; if any problem, just give up. +Arrange to recover the dynamic store afterwards. */ + +reset_point = store_mark(); +sprintf(CS buffer, "%s-H", p->name); +if (spool_read_header(buffer, FALSE, TRUE) != spool_read_OK) + { + store_reset(reset_point); + if (jread != NULL) fclose(jread); + return; + } + +/* If there's a journal file, add its contents to the non-recipients tree */ + +if (jread != NULL) + { + while (Ufgets(big_buffer, big_buffer_size, jread) != NULL) + { + int n = Ustrlen(big_buffer); + big_buffer[n-1] = 0; + tree_add_nonrecipient(big_buffer); + } + fclose(jread); + } + +/* Scan and process the recipients list, removing any that have already +been delivered, and removing visible names. In the nonrecipients tree, +domains are lower cased. */ + +if (recipients_list) + for (i = 0; i < recipients_count; i++) + { + uschar * pp; + uschar * r = recipients_list[i].address; + tree_node * node; + + if (!(node = tree_search(tree_nonrecipients, r))) + node = tree_search(tree_nonrecipients, string_copylc(r)); + + if ((pp = strstric(r+1, qualify_domain, FALSE)) && *(--pp) == '@') + *pp = 0; + if (!node) + (void)find_dest(p, r, dest_add, FALSE); + else + (void)find_dest(p, r, dest_remove, FALSE); + } + +/* We also need to scan the tree of non-recipients, which might +contain child addresses that are not in the recipients list, but +which may have got onto the address list as a result of eximon +noticing an == line in the log. Then remember the update time, +recover the dynamic store, and we are done. */ + +scan_tree(p, tree_nonrecipients); +p->update_time = statdata.st_mtime; +store_reset(reset_point); +} + + + +/************************************************* +* Display queue data * +*************************************************/ + +/* The present implementation simple re-writes the entire information each +time. Take some care to keep the scrolled position as it previously was, but, +if it was at the bottom, keep it at the bottom. Take note of any hide list, and +time out the entries as appropriate. */ + +void +queue_display(void) +{ +int now = (int)time(NULL); +queue_item *p = queue_index[0]; + +if (menu_is_up) return; /* Avoid nasty interactions */ + +text_empty(queue_widget); + +while (p != NULL) + { + int count = 1; + dest_item *dd, *ddd; + uschar u = 'm'; + int t = (now - p->input_time)/60; /* minutes on queue */ + + if (t > 90) + { + u = 'h'; + t = (t + 30)/60; + if (t > 72) + { + u = 'd'; + t = (t + 12)/24; + if (t > 99) /* someone had > 99 days */ + { + u = 'w'; + t = (t + 3)/7; + if (t > 99) /* so, just in case */ + { + u = 'y'; + t = (t + 26)/52; + } + } + } + } + + update_recipients(p); /* update destinations */ + + /* Can't set this earlier, as header data may change things. */ + + dd = p->destinations; + + /* Check to see if this message is on the hide list; if any hide + item has timed out, remove it from the list. Hide if all destinations + are on the hide list. */ + + for (ddd = dd; ddd != NULL; ddd = ddd->next) + { + skip_item *sk; + skip_item **skp; + int len_address; + + if (ddd->address[0] == '*') break; + len_address = Ustrlen(ddd->address); + + for (skp = &queue_skip; ; skp = &(sk->next)) + { + int len_skip; + + sk = *skp; + while (sk != NULL && now >= sk->reveal) + { + *skp = sk->next; + store_free(sk); + sk = *skp; + if (queue_skip == NULL) + { + XtDestroyWidget(unhide_widget); + unhide_widget = NULL; + } + } + if (sk == NULL) break; + + /* If this address matches the skip item, break (sk != NULL) */ + + len_skip = Ustrlen(sk->text); + if (len_skip <= len_address && + Ustrcmp(ddd->address + len_address - len_skip, sk->text) == 0) + break; + } + + if (sk == NULL) break; + } + + /* Don't use more than one call of anon() in one statement - it uses + a fixed static buffer. */ + + if (ddd != NULL || dd == NULL) + { + text_showf(queue_widget, "%c%2d%c %s %s %-8s ", + (p->frozen)? '*' : ' ', + t, u, + string_format_size(p->size, big_buffer), + p->name, + (p->sender == NULL)? US" " : + (p->sender[0] == 0)? US"<> " : anon(p->sender)); + + text_showf(queue_widget, "%s%s%s", + (dd == NULL || dd->address[0] == '*')? "" : "<", + (dd == NULL)? US"" : anon(dd->address), + (dd == NULL || dd->address[0] == '*')? "" : ">"); + + if (dd != NULL && dd->parent != NULL && dd->parent->address[0] != '*') + text_showf(queue_widget, " parent <%s>", anon(dd->parent->address)); + + text_show(queue_widget, US"\n"); + + if (dd != NULL) dd = dd->next; + while (dd != NULL && count++ < queue_max_addresses) + { + text_showf(queue_widget, " <%s>", + anon(dd->address)); + if (dd->parent != NULL && dd->parent->address[0] != '*') + text_showf(queue_widget, " parent <%s>", anon(dd->parent->address)); + text_show(queue_widget, US"\n"); + dd = dd->next; + } + if (dd != NULL) + text_showf(queue_widget, " ...\n"); + } + + p = p->next; + } +} + +/* End of em_queue.c */ diff --git a/exim_monitor/em_strip.c b/exim_monitor/em_strip.c new file mode 100644 index 0000000..03864d2 --- /dev/null +++ b/exim_monitor/em_strip.c @@ -0,0 +1,266 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2009 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +#include "em_hdr.h" + +/* This module contains functions for handling stripcharts */ + + +/************************************************* +* Static variables * +*************************************************/ + +static int queue_first_time = 1; /* flag for resetting time */ +static int size_first_time = 1; /* and another */ + +static int stripchart_count = 0; /* count stripcharts created */ +static int *stripchart_delay; /* vector of delay counts */ +static Widget *stripchart_label; /* vector of label widgets */ +static int *stripchart_last_total; /* vector of previous values */ +static int *stripchart_max; /* vector of maxima */ +static int *stripchart_middelay; /* vector of */ +static int *stripchart_midmax; /* vector of */ +static uschar **stripchart_name; /* vector of name strings */ +static Widget stripchart_prev_chart = NULL; /* previously created chart */ +static Widget stripchart_prev_label = NULL; /* previously created label */ + + + +/************************************************* +* Initialize * +*************************************************/ + +void stripchart_init(void) +{ +stripchart_delay = (int *)store_malloc(stripchart_number * sizeof(int)); +stripchart_label = (Widget *)store_malloc(stripchart_number * sizeof(Widget)); +stripchart_last_total = (int *)store_malloc(stripchart_number * sizeof(int)); +stripchart_max = (int *)store_malloc(stripchart_number * sizeof(int)); +stripchart_middelay = (int *)store_malloc(stripchart_number * sizeof(int)); +stripchart_midmax = (int *)store_malloc(stripchart_number * sizeof(int)); +stripchart_name = (uschar **)store_malloc(stripchart_number * sizeof(uschar *)); +stripchart_total = (int *)store_malloc(stripchart_number * sizeof(int)); +} + + + +/************************************************* +* Stripchart callback function * +*************************************************/ + +/* The client data is the index of the stripchart. We have to play +a little game in order to ensure that the double value is correctly +passed back via the value pointer without the compiler doing an +unwanted cast. */ + +static void +stripchartAction(Widget w, XtPointer client_data, XtPointer value) +{ +double * ptr = (double *)value; +static int thresholds[] = + {10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 0}; +int num = (long)client_data; +int oldmax = 0; +int newmax = 0; +int newvalue = 0; +int i = 0; + +/* For the queue stripchart, the value is the current vector value. +We reset the initial delay of 1 second to the normal value. */ + +if (num == 0) + { + newvalue = stripchart_total[0]; + if (queue_first_time) + { + xs_SetValues(w, 1, "update", stripchart_update); + queue_first_time = 0; + } + } + +/* For the size monitoring stripchart, the value is the percentage +fullness of the partition. A similar fudge to the above is implemented +for the first time. Not all OS have statvfs(); for those that don't this +code is omitted. In fact it should never be obeyed, as we don't allow +size_stripchart to get set in that case. For some OS the old function +and struct name statfs is used; that is handled by a macro. */ + +else if (size_stripchart != NULL && num == 1) + { +#ifdef HAVE_STATFS + struct statvfs statbuf; + if (statvfs(CS size_stripchart, &statbuf) == 0) + { + int used = statbuf.f_blocks - statbuf.f_bfree; + int max = used + statbuf.f_bavail; + double fraction = ((double)used) / ((double)max); + newvalue = (int)((fraction + 0.005) * 100.0); + } +#endif + if (size_first_time) + { + xs_SetValues(w, 1, "update", stripchart_update); + size_first_time = 0; + } + } + +/* For the configured stripcharts, the value to be set is +the difference from last time; save the current total for +next time. */ + +else + { + newvalue = stripchart_total[num] - stripchart_last_total[num]; + stripchart_last_total[num] = stripchart_total[num]; + } + +/* Adjust the scale of the stripchart according to the value; +we delay enlarging the scale for a while after the values +reduce. Keep the maximum value while delaying, and reset +down to that. For the size stripchart, the threshold is always +forced to be at least 100. */ + +while (thresholds[i] > 0) + { + int thresh = (size_stripchart != NULL && num == 1)? 100 : thresholds[i++]; + if (newvalue < (double)thresh) + { + /* If the current maximum is less than required, or if it is + greater and we have delayed long enough, adjust the scale. */ + + if (stripchart_max[num] < thresh || + (stripchart_max[num] > thresh && stripchart_delay[num]++ > 20)) + { + uschar buffer[128]; + newmax = (thresh > stripchart_midmax[num])? + thresh : stripchart_midmax[num]; + if (newmax == 10) sprintf(CS buffer, "%s", stripchart_name[num]); + else sprintf(CS buffer, "%s x%d", stripchart_name[num], newmax/10); + if (size_stripchart != NULL && num == 1) Ustrcat(buffer, US"%"); + xs_SetValues(stripchart_label[num], 1, "label", buffer); + oldmax = stripchart_max[num]; + stripchart_max[num] = newmax; + stripchart_midmax[num] = 0; + stripchart_delay[num] -= stripchart_middelay[num]; + } + + /* Otherwise, if the current maximum is greater than required, + keep the highest value encountered during the delay, and its + position so we can adjust the delay when re-scaling. */ + + else if (stripchart_max[num] > thresh) + { + if (thresh > stripchart_midmax[num]) + { + stripchart_midmax[num] = thresh; + stripchart_middelay[num] = stripchart_delay[num]; + } + } + + /* If the maximum is exactly what we need, reset the delay. */ + + if (stripchart_max[num] == thresh) stripchart_delay[num] = 0; + break; + } + } + +/* The vanilla Athena stripchart widget does not support change of +scale - it just draws scale lines closer and closer together, which +doesn't work when the number gets very large. However, we can cause +it to change scale quite simply by recomputing all the values and +then calling its repaint routine. I had to nobble the repaint routine +too, to stop it changing scale to anything other than 10. There's +probably a better way to do this, like adding some new resource, but +I'm not a widget programmer and want to get on with the rest of +eximon... */ + +if (oldmax > 0) + { + int i; + StripChartWidget ww = (StripChartWidget)w; + ww->strip_chart.max_value = 0; + for (i = 0; i < (int)ww->strip_chart.interval; i++) + { + ww->strip_chart.valuedata[i] = + (ww->strip_chart.valuedata[i] * oldmax)/newmax; + if (ww->strip_chart.valuedata[i] > ww->strip_chart.max_value) + ww->strip_chart.max_value = ww->strip_chart.valuedata[i]; + } + XClearWindow( XtDisplay(w), XtWindow(w)); + ww->strip_chart.interval = repaint_window(ww, 0, (int)w->core.width); + } + +/* Pass back the new value at the new scale */ + +*ptr = ((double)newvalue * 10.0)/(double)(stripchart_max[num]); +} + + + +/************************************************* +* Create one stripchart * +*************************************************/ + +/* This function creates two widgets, one being the title and the other being +the stripchart. The client_data values for each stripchart are index into the +stripchart_values vector; each new stripchart just gets the next number. There +is a fudge for the very first stripchart, which is the queue length display, +and for the second if it is a partition size display; its update time is +initially set to 1 second so that it gives an immediate display of the queue. +The first time its callback function is obeyed, the update time gets reset. */ + +void +create_stripchart(Widget parent, uschar *title) +{ +Widget chart; + +Widget label = XtCreateManagedWidget("label", + labelWidgetClass, parent, NULL, 0); + +xs_SetValues(label, 10, + "label", title, + "width", stripchart_width + 2, + "borderWidth", 0, + "internalHeight", 0, + "internalWidth", 0, + "left", XawChainLeft, + "right", XawChainLeft, + "top", XawChainTop, + "bottom", XawChainTop, + XtNfromHoriz, stripchart_prev_label); + +chart = XtCreateManagedWidget("stripchart", + mystripChartWidgetClass, parent, NULL, 0); + +xs_SetValues(chart, 11, + "jumpScroll", 1, + "update", (stripchart_count < stripchart_varstart)? 1:stripchart_update, + "minScale", 10, + "width", stripchart_width, + "height", stripchart_height, + "left", XawChainLeft, + "right", XawChainLeft, + "top", XawChainTop, + "bottom", XawChainTop, + XtNfromHoriz, stripchart_prev_chart, + XtNfromVert, label); + +XtAddCallback(chart, "getValue", stripchartAction, + (XtPointer)(long)stripchart_count); + +stripchart_last_total[stripchart_count] = 0; +stripchart_max[stripchart_count] = 10; +stripchart_midmax[stripchart_count] = 0; +stripchart_name[stripchart_count] = title; +stripchart_prev_label = stripchart_label[stripchart_count] = label; +stripchart_prev_chart = chart; +stripchart_total[stripchart_count] = 0; +stripchart_count++; +} + +/* End of em_strip.c */ diff --git a/exim_monitor/em_text.c b/exim_monitor/em_text.c new file mode 100644 index 0000000..3a36829 --- /dev/null +++ b/exim_monitor/em_text.c @@ -0,0 +1,73 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2012 */ +/* See the file NOTICE for conditions of use and distribution. */ + + +#include "em_hdr.h" + + +/* This module contains functions for displaying text in a +text widget. It is not used for the log widget, because that +is dynamically updated and has special scrolling requirements. */ + + +/* Count of characters displayed */ + +static int text_count = 0; + + +/************************************************* +* Empty the widget * +*************************************************/ + +void text_empty(Widget w) +{ +XawTextBlock b; +b.firstPos = 0; +b.ptr = CS &b; +b.format = FMT8BIT; +b.length = 0; +XawTextReplace(w, 0, text_count, &b); +text_count = 0; +XawTextSetInsertionPoint(w, text_count); +} + + + +/************************************************* +* Display text * +*************************************************/ + +void text_show(Widget w, uschar *s) +{ +XawTextBlock b; +b.firstPos = 0; +b.ptr = CS s; +b.format = FMT8BIT; +b.length = Ustrlen(s); +XawTextReplace(w, text_count, text_count, &b); +text_count += b.length; +XawTextSetInsertionPoint(w, text_count); +} + + +/************************************************* +* Display text from format * +*************************************************/ + +void text_showf(Widget w, char *s, ...) PRINTF_FUNCTION(2,3); + +void text_showf(Widget w, char *s, ...) +{ +va_list ap; +uschar buffer[1024]; +va_start(ap, s); +vsprintf(CS buffer, s, ap); +va_end(ap); +text_show(w, buffer); +} + +/* End of em_text.c */ diff --git a/exim_monitor/em_version.c b/exim_monitor/em_version.c new file mode 100644 index 0000000..336f2ae --- /dev/null +++ b/exim_monitor/em_version.c @@ -0,0 +1,65 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge 1995 - 2018 */ +/* Copyright (c) The Exim Maintainers 2020 */ +/* See the file NOTICE for conditions of use and distribution. */ + +#define EM_VERSION_C + +/* Needed by macros.h */ +/* Some systems have PATH_MAX and some have MAX_PATH_LEN. */ + +#ifndef PATH_MAX +# ifdef MAX_PATH_LEN +# define PATH_MAX MAX_PATH_LEN +# else +# define PATH_MAX 1024 +# endif +#endif + +#include "mytypes.h" +#include "store.h" +#include "macros.h" +#include <string.h> +#include <stdlib.h> + +#include "version.h" + +extern uschar *version_string; +extern uschar *version_date; + +void +version_init(void) +{ +int i = 0; +uschar today[20]; + +version_string = US"2.06"; + +#ifdef EXIM_BUILD_DATE_OVERRIDE +/* Reproducible build support; build tooling should have given us something looking like + * "25-Feb-2017 20:15:40" in EXIM_BUILD_DATE_OVERRIDE based on $SOURCE_DATE_EPOCH in environ + * per <https://reproducible-builds.org/specs/source-date-epoch/> + */ +version_date = US malloc(32); +version_date[0] = 0; +Ustrncat(version_date, EXIM_BUILD_DATE_OVERRIDE, 31); + +#else +Ustrcpy(today, US __DATE__); +if (today[4] == ' ') i = 1; +today[3] = today[6] = '-'; + +version_date = US malloc(32); +version_date[0] = 0; +Ustrncat(version_date, today+4+i, 3-i); +Ustrncat(version_date, today, 4); +Ustrncat(version_date, today+7, 4); +Ustrcat(version_date, US" "); +Ustrcat(version_date, US __TIME__); +#endif +} + +/* End of em_version.c */ diff --git a/exim_monitor/em_xs.c b/exim_monitor/em_xs.c new file mode 100644 index 0000000..ee91f7c --- /dev/null +++ b/exim_monitor/em_xs.c @@ -0,0 +1,45 @@ +/************************************************* +* Exim Monitor * +*************************************************/ + +/* Copyright (c) University of Cambridge, 1995 - 2016 */ +/* See the file NOTICE for conditions of use and distribution. */ + +/* This file contains a number of subroutines that are in effect +just alternative packaging for calls to various X functions that +happen to be convenient for this program. */ + +#include "em_hdr.h" + + + +/************************************************* +* xs_SetValues * +*************************************************/ + +/* Unpick a variable-length argument list and set up an +appropriate call to XtSetValues. To make it reasonably +efficient, we keep a working Arg structure of length 15; +the largest call in eximon sets 11 values. The code uses +malloc/free if more, just in case there is ever a longer +one that gets overlooked. */ + +static Arg xs_temparg[15]; + +void xs_SetValues(Widget w, Cardinal num_args, ...) +{ +int i; +va_list ap; +Arg *aa = (num_args > 15)? store_malloc(num_args*sizeof(Arg)) : xs_temparg; +va_start(ap, num_args); +for (i = 0; i < num_args; i++) + { + aa[i].name = va_arg(ap, String); + aa[i].value = va_arg(ap, XtArgVal); + } +va_end(ap); +XtSetValues(w, aa, num_args); +if (num_args > 15) store_free(aa); +} + +/* End of em_xs.c */ |