xmem/xmem.c

/*
 * xmem - display memory/swap usage utility for X
 *
 * Copyright 2017 Christian Barthel <bch@onfire.org>
 * Copyright 1989 Massachusetts Institute of Technology
 *
 * $XConsortium: xload.c,v 1.36 91/05/24 16:57:46 converse Exp $
 */

#include <unistd.h>
#include <stdio.h>
#include <err.h>
#include <errno.h>
#include <X11/Intrinsic.h>
#include <X11/Xatom.h>
#include <X11/StringDefs.h>
#include <X11/Shell.h>

#include <X11/Xaw/Cardinals.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/Paned.h>
#include <X11/Xaw/StripChart.h>
#include <X11/Xmu/SysUtil.h>
#include "MemStripChart.h"

#include "xmem.bit"

extern void exit();

#include "get_mem.h"

static void quit();

/*
 * Definition of the Application resources structure.
 */

typedef struct _XLoadResources {
    Boolean show_label;
    Boolean use_lights;
} XLoadResources;

/*
 * Command line options table.  Only resources are entered here...there is a
 * pass over the remaining options after XtParseCommand is let loose.
 */

static XrmOptionDescRec options_mem[] = {
    {"-scale",		"*mem.minScale",	XrmoptionSepArg,	NULL},
    {"-update",		"*mem.update",		XrmoptionSepArg,	NULL},
    {"-hl",		"*mem.highlight",	XrmoptionSepArg,	NULL},
    {"-highlight",		"*mem.highlight",	XrmoptionSepArg,	NULL},
    {"-codecolor",		"*mem.codecolor",       XrmoptionSepArg,	NULL},
    {"-cachedcolor",	"*mem.cachedcolor",	XrmoptionSepArg,	NULL},
    {"-buffercolor",	"*mem.buffercolor",	XrmoptionSepArg,	NULL},
    {"-freecolor",		"*mem.freecolor",	XrmoptionSepArg,	NULL},
    {"-swapcolor",		"*mem.swapcolor",	XrmoptionSepArg,	NULL},
    {"-jumpscroll",	"*mem.jumpScroll",	XrmoptionSepArg,	NULL},
    {"-label",		"*label.label",		XrmoptionSepArg,	NULL},
    {"-nolabel",		"*showLabel",	        XrmoptionNoArg,       "False"},
    {"-lights",		"*useLights",		XrmoptionNoArg,	      "True"},
};

/*
 * The structure containing the resource information for the
 * Xload application resources.
 */

#define Offset(field) (XtOffsetOf(XLoadResources, field))

static XtResource my_resources_mem[] = {
    {"showLabel", XtCBoolean, XtRBoolean, sizeof(Boolean),
	 Offset(show_label), XtRImmediate, (XtPointer) TRUE},
};

#undef Offset

static XLoadResources resources;

static XtActionsRec xload_actions[] = {
    { "quit",	quit },
};
static Atom wm_delete_window;

/*
 * Exit with message describing command line format.
 */

void usage(char *progname)
{
    fprintf (stderr, "usage:  %s [-options ...]\n\n", progname);
    fprintf (stderr, "where options include:\n");
    fprintf (stderr,
	     "    -display dpy            X server on which to display\n");
    fprintf (stderr,
	     "    -geometry geom          size and location of window\n");
    fprintf (stderr,
	     "    -fn font                font to use in label\n");
    fprintf (stderr,
	     "    -update seconds         interval between updates\n");
    fprintf (stderr,
	     "    -label string           annotation text\n");
    fprintf (stderr,
	     "    -bg color               background color\n");
    fprintf (stderr,
	     "    -fg color               text color\n");

    fprintf (stderr,
	     "    -hl color               scale color\n");
    fprintf (stderr,
	     "    -codecolor color        used code and stack memory color\n");
    fprintf (stderr,
	     "    -cachedcolor color      used cached memory color\n");
    fprintf (stderr,
	     "    -buffercolor color      used buffer memory color\n");
    fprintf (stderr,
	     "    -freecolor color        used free memory color\n");
    fprintf (stderr,
	     "    -swapcolor color        used swap memory color\n");
    fprintf (stderr,
	     "    -nolabel                removes the label from above the chart.\n");
    fprintf (stderr,
	     "    -jumpscroll value       number of pixels to scroll on overflow\n");
    fprintf (stderr,
	     "The reference line refers to the avaible installed ram\n");

    fprintf (stderr, "\n");
    exit(1);
}

int main(int argc, char **argv)
{
	XtAppContext app_con;
	Widget toplevel, load, pane, label_wid, load_parent;
	Arg args[1];
	Pixmap icon_pixmap = None;
	char *label, host[256];
	
	/* For security reasons, we reset our uid/gid after doing the necessary
		 system initialization and before calling any X routines. */
	
	if (setgid(getgid()) == -1) 
		errx(1, "%s: setgid failed: %s\n", argv[0], strerror(errno));
	if (setuid(getuid()) == -1) 
		errx(1, "%s: setuid failed: %s\n", argv[0], strerror(errno));
	
	toplevel = XtAppInitialize(&app_con, "XMem", options_mem, XtNumber(options_mem),
														 &argc, argv, NULL, NULL, (Cardinal) 0);
	
	if (argc != 1) usage(argv[0]);
	
	XtGetApplicationResources( toplevel, (XtPointer) &resources,
														 my_resources_mem, XtNumber(my_resources_mem),
														 NULL, (Cardinal) 0);
	/*
	 * This is a hack so that f.delete will do something useful in this
	 * single-window application.
	 */
	XtAppAddActions (app_con, xload_actions, XtNumber(xload_actions));
	XtOverrideTranslations(toplevel,
												 XtParseTranslationTable ("<Message>WM_PROTOCOLS: quit()"));
	
	XtSetArg (args[0], XtNiconPixmap, &icon_pixmap);
	XtGetValues(toplevel, args, ONE);
	if (icon_pixmap == None) {
		XtSetArg(args[0], XtNiconPixmap,
						 XCreateBitmapFromData(XtDisplay(toplevel),
																	 XtScreen(toplevel)->root,
																	 (char *)xload_bits,
																	 xload_width, xload_height));
		XtSetValues (toplevel, args, ONE);
	}
	
	if (resources.show_label) {
		pane = XtCreateManagedWidget ("paned", panedWidgetClass,
																	toplevel, NULL, ZERO);
		
		label_wid = XtCreateManagedWidget ("label", labelWidgetClass,
																			 pane, NULL, ZERO);
		
		XtSetArg (args[0], XtNlabel, &label);
		XtGetValues(label_wid, args, ONE);
		
		if ( strcmp("label", label) == 0 ) {
	    (void) XmuGetHostname (host, 255);
	    XtSetArg (args[0], XtNlabel, host);
	    XtSetValues (label_wid, args, ONE);
		}
		
		load_parent = pane;
	}
	else
		load_parent = toplevel;
	
	
	load = XtCreateManagedWidget ("mem", memStripChartWidgetClass,
																load_parent, NULL, ZERO);
	XtAddCallback(load, XtNgetValue, (void*)GetMemLoadPoint, NULL);
	
	XtRealizeWidget (toplevel);
	wm_delete_window = XInternAtom (XtDisplay(toplevel), "WM_DELETE_WINDOW",
																	False);
	(void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel),
													&wm_delete_window, 1);

	if (pledge("ps vminfo stdio", NULL) == -1) 
		errx(1, "pledge failed: %s", strerror(errno)); 

	XtAppMainLoop(app_con);
	return 0; 
}


static void quit (Widget w, XEvent *event, String *params, Cardinal *num_params)
{
	if (event->type == ClientMessage &&
			event->xclient.data.l[0] != wm_delete_window) {
		XBell (XtDisplay(w), 0);
		return;
	}
	XtDestroyApplicationContext(XtWidgetToApplicationContext(w));
	exit (0);
}