~ctwm/ctwm/trunk

/*

 * Parser -- M4 specific routines.  Some additional stuff from parse.c

 * should probably migrate here over time.

 */

#include "ctwm.h"

#include <sys/types.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <netdb.h>

#include <pwd.h>

#include "screen.h"

#include "parse.h"

#include "parse_int.h"

#include "version.h"

static char *m4_defs(Display *display, char *host);

/*

 * Primary entry point to do m4 parsing of a startup file

 */

FILE *start_m4(FILE *fraw)

{

	int fno;

	int fids[2];

	int fres;

	char *defs_file;

	/* We'll need to work in file descriptors, not stdio FILE's */

	fno = fileno(fraw);

	/* Write our our standard definitions into a temp file */

	defs_file = m4_defs(dpy, CLarg.display_name);

	/* We'll read back m4's output over a pipe */

	pipe(fids);

	/* Fork off m4 as a child */

	fres = fork();

	if(fres < 0) {

		perror("Fork for " M4CMD " failed");

		unlink(defs_file);

		exit(23);

	}

	/*

	 * Child: setup and spawn m4, and have it write its output into one

	 * end of our pipe.

	 */

	if(fres == 0) {

		/* Setup file descriptors */

		close(0);               /* stdin */

		close(1);               /* stdout */

		dup2(fno, 0);           /* stdin = fraw */

		dup2(fids[1], 1);       /* stdout = pipe to parent */

		/*

		 * Kick off m4, telling it both our file of definitions, and

		 * stdin (dup of the .[c]twmrc file descriptor above) as input.

		 * It writes to stdout (one end of our pipe).

		 */

		execlp(M4CMD, M4CMD, "-s", defs_file, "-", NULL);

		/* If we get here we are screwed... */

		perror("Can't execlp() " M4CMD);

		unlink(defs_file);

		exit(124);

	}

	/*

	 * Else we're the parent; hand back our reading end of the pipe.

	 */

	close(fids[1]);

	return (fdopen(fids[0], "r"));

}

/*

 * Utils: Generate m4 definition lines for string or numeric values.

 * Just use a static buffer of a presumably crazy overspec size; it's

 * unlikely any lines will push more than 60 or 80 chars.

 */

#define MAXDEFLINE 4095

static const char *MkDef(const char *name, const char *def)

{

	static char cp[MAXDEFLINE + 1]; /* +1 for \n on error */

	int pret;

	/* Best response to an empty value is probably just nothing */

	if(def == NULL) {

		return ("");

	}

	/* Put together */

	pret = snprintf(cp, MAXDEFLINE, "define(`%s', `%s')\n", name, def);

	/* Be gracefulish about ultra-long lines */

	if(pret >= MAXDEFLINE) {

		pret = snprintf(cp, MAXDEFLINE, "dnl Define for '%s' too long: %d "

		                "chars, limit %d\n", name, pret, MAXDEFLINE);

		if(pret >= MAXDEFLINE) {

			/* In case it was name that blew out the length */

			*(cp + MAXDEFLINE - 1) = '\n';

			*(cp + MAXDEFLINE)     = '\0';

		}

	}

	return(cp);

}

static const char *MkNum(const char *name, int def)

{

	char num[32];

	/*

	 * 2**64 is only 20 digits, so we've got plenty of headroom.  Don't

	 * even bother checking the size wasn't exceeded.

	 */

	snprintf(num, 32, "%d", def);

	return(MkDef(name, num));

}

/* Technically should sysconf() this, but good enough for our purposes */

#define MAXHOSTNAME 255

/*

 * Writes out a temp file of all the m4 defs appropriate for this run,

 * and returns the file name

 */

static char *m4_defs(Display *display, char *host)

{

	Screen *screen;

	Visual *visual;

	char client[MAXHOSTNAME], server[MAXHOSTNAME], *colon;

	struct hostent *hostname;

	char *vc, *color;

	static char tmp_name[] = "/tmp/ctwmrcXXXXXX";

	int fd;

	FILE *tmpf;

	char *user;

	/* Create temp file */

	fd = mkstemp(tmp_name);

	if(fd < 0) {

		perror("mkstemp failed in m4_defs");

		exit(377);

	}

	tmpf = fdopen(fd, "w+");

	/*

	 * Now start writing the defs into it.

	 */

#define WR_DEF(k, v) fputs(MkDef((k), (v)), tmpf)

#define WR_NUM(k, v) fputs(MkNum((k), (v)), tmpf)

	/*

	 * The machine running the window manager process (and, presumably,

	 * most of the other clients the user is running)

	 */

	if(gethostname(client, MAXHOSTNAME) < 0) {

		perror("gethostname failed in m4_defs");

		exit(1);

	}

	WR_DEF("CLIENTHOST", client);

	/*

	 * A guess at the machine running the X server.  We take the full

	 * $DISPLAY and chop off the screen specification.

	 */

	/* stpncpy() a better choice */

	snprintf(server, sizeof(server), "%s", XDisplayName(host));

	colon = strchr(server, ':');

	if(colon != NULL) {

		*colon = '\0';

	}

	/* :0 or unix socket connection means it's the same as CLIENTHOST */

	if((server[0] == '\0') || (!strcmp(server, "unix"))) {

		strcpy(server, client);

	}

	WR_DEF("SERVERHOST", server);

	/* DNS (/NSS) lookup can't be the best way to do this, but... */

	hostname = gethostbyname(client);

	if(hostname) {

		WR_DEF("HOSTNAME", hostname->h_name);

	}

	else {

		WR_DEF("HOSTNAME", client);

	}

	/*

	 * Info about the user and their environment

	 */

	if(!(user = getenv("USER")) && !(user = getenv("LOGNAME"))) {

		struct passwd *pwd = getpwuid(getuid());

		if(pwd) {

			user = pwd->pw_name;

		}

	}

	if(!user) {

		user = "unknown";

	}

	WR_DEF("USER", user);

	WR_DEF("HOME", getenv("HOME"));

	/*

	 * ctwm meta

	 */

	WR_DEF("TWM_TYPE", "ctwm");

	WR_DEF("TWM_VERSION", VersionNumber);

	WR_DEF("CTWM_VERSION_MAJOR", VersionNumber_major);

	WR_DEF("CTWM_VERSION_MINOR", VersionNumber_minor);

	WR_DEF("CTWM_VERSION_PATCH", VersionNumber_patch);

	WR_DEF("CTWM_VERSION_ADDL",  VersionNumber_addl);

	/*

	 * X server meta

	 */

	WR_NUM("VERSION", ProtocolVersion(display));

	WR_NUM("REVISION", ProtocolRevision(display));

	WR_DEF("VENDOR", ServerVendor(display));

	WR_NUM("RELEASE", VendorRelease(display));

	/*

	 * Information about the display

	 */

	screen = ScreenOfDisplay(display, Scr->screen);

	visual = DefaultVisualOfScreen(screen);

	WR_NUM("WIDTH", screen->width);

	WR_NUM("HEIGHT", screen->height);

#define Resolution(pixels, mm)  ((((pixels) * 100000 / (mm)) + 50) / 100)

	WR_NUM("X_RESOLUTION", Resolution(screen->width, screen->mwidth));

	WR_NUM("Y_RESOLUTION", Resolution(screen->height, screen->mheight));

#undef Resolution

	WR_NUM("PLANES", DisplayPlanes(display, Scr->screen));

	WR_NUM("BITS_PER_RGB", visual->bits_per_rgb);

	color = "Yes";

	switch(visual->class) {

		case(StaticGray):

			vc = "StaticGray";

			color = "No";

			break;

		case(GrayScale):

			vc = "GrayScale";

			color = "No";

			break;

		case(StaticColor):

			vc = "StaticColor";

			break;

		case(PseudoColor):

			vc = "PseudoColor";

			break;

		case(TrueColor):

			vc = "TrueColor";

			break;

		case(DirectColor):

			vc = "DirectColor";

			break;

		default:

			vc = "NonStandard";

			break;

	}

	WR_DEF("CLASS", vc);

	WR_DEF("COLOR", color);

	/*

	 * Bits of "how this ctwm invocation is being run" data

	 */

	if(CLarg.is_captive && Scr->captivename) {

		WR_DEF("TWM_CAPTIVE", "Yes");

		WR_DEF("TWM_CAPTIVE_NAME", Scr->captivename);

	}

	else {

		WR_DEF("TWM_CAPTIVE", "No");

	}

	/*

	 * Various compile-time options.

	 */

#ifdef PIXMAP_DIRECTORY

	WR_DEF("PIXMAP_DIRECTORY", PIXMAP_DIRECTORY);

#endif

#ifdef XPM

	WR_DEF("XPM", "Yes");

#endif

#ifdef JPEG

	WR_DEF("JPEG", "Yes");

#endif

#ifdef SOUNDS

	WR_DEF("SOUNDS", "Yes");

#endif

#ifdef EWMH

	WR_DEF("EWMH", "Yes");

#endif

	/* Since this is no longer an option, it should be removed in the future */

	WR_DEF("I18N", "Yes");

#undef WR_NUM

#undef WR_DEF

	/*

	 * We might be keeping it, in which case tell the user where it is;

	 * this is mostly a debugging option.  Otherwise, delete it by

	 * telling m4 to do so when it reads it; this is fairly fugly, and I

	 * have more than half a mind to dike it out and properly clean up

	 * ourselves.

	 */

	if(CLarg.KeepTmpFile) {

		fprintf(stderr, "Left file: %s\n", tmp_name);

	}

	else {

		fprintf(tmpf, "syscmd(/bin/rm %s)\n", tmp_name);

	}

	/* Close out and hand it back */

	fclose(tmpf);

	return(tmp_name);

}