9base

dwbinit.c (9219B)

---

 /*
  *
  * Pathname management routines for DWB C programs.
  *
  * Applications should initialize a dwbinit array with the string
  * pointers and arrays that need to be updated, and then hand that
  * array to DWBinit before much else happens in their main program.
  * DWBinit calls DWBhome to get the current home directory. DWBhome
  * uses the last definition of DWBENV (usually "DWBHOME") in file
  * DWBCONFIG (e.g., /usr/lib/dwb3.4) or the value assigned to that
  * variable in the environment if the DWBCONFIG file doesn't exist,
  * can't be read, or doesn't define DWBENV.
  *
  * DWBCONFIG must be a simple shell script - comments, a definition
  * of DWBHOME, and perhaps an export or echo is about all that's
  * allowed. The parsing in DWBhome is simple and makes no attempt
  * to duplicate the shell. It only looks for DWBHOME= as the first
  * non-white space string on a line, so
  *
  *	#
  *	# A sample DWBCONFIG shell script
  *	#
  *
  *	DWBHOME=/usr/add-on/dwb3.4
  *	export DWBHOME
  *
  * means DWBhome would return "/usr/add-on/dwb3.4" for the DWB home
  * directory. A DWBCONFIG file means there can only be one working
  * copy of a DWB release on a system, which seems like a good idea.
  * Using DWBCONFIG also means programs will always include correct
  * versions of files (e.g., prologues or macro packages).
  *
  * Relying on an environment variable guarantees nothing. You could
  * execute a version of dpost, but your environment might point at
  * incorrect font tables or prologues. Despite the obvious problems
  * we've also implemented an environment variable approach, but it's
  * only used if there's no DWBCONFIG file.
  *
  * DWBinit calls DWBhome to get the DWB home directory prefix and
  * then marches through its dwbinit argument, removing the default
  * home directory and prepending the new home. DWBinit stops when
  * it reaches an element that has NULL for its address and value
  * fields. Pointers in a dwbinit array are reallocated and properly
  * initialized; arrays are simply reinitialized if there's room.
  * All pathnames that are to be adjusted should be relative. For
  * example,
  *
  *	char	*fontdir = "lib/font";
  *	char	xyzzy[25] = "etc/xyzzy";
  *
  * would be represented in a dwbinit array as,
  *
  *	dwbinit allpaths[] = {
  *		&fontdir, NULL, 0,
  *		NULL, xyzzy, sizeof(xyzzy),
  *		NULL, NULL, 0
  *	};
  *		
  * The last element must have NULL entries for the address and
  * value fields. The main() routine would then do,
  *
  *	#include "dwbinit.h"
  *
  *	main() {
  *
  *		DWBinit("program name", allpaths);
  *		...
  *	}
  *
  * Debugging is enabled if DWBDEBUG is in the environment and has
  * the value ON. Output is occasionally useful and probably should
  * be documented.
  *
  */
 
 #include <u.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
 
 #include "dwbinit.h"
 
 #ifndef DWBCONFIG
 #define DWBCONFIG	"/dev/null"
 #endif
 
 #ifndef DWBENV
 #define DWBENV		"DWBHOME"
 #endif
 
 #ifndef DWBHOME
 #define DWBHOME		""
 #endif
 
 #ifndef DWBDEBUG
 #define DWBDEBUG	"DWBDEBUG"
 #endif
 
 #ifndef DWBPREFIX
 #define DWBPREFIX	"\\*(.P"
 #endif
 
 /*****************************************************************************/
 
 void DWBdebug(dwbinit *ptr, int level)
 {
 
     char	*path;
     char	*home;
     static char	*debug = NULL;
 
 /*
  *
  * Debugging output, but only if DWBDEBUG is defined to be ON in the
  * environment. Dumps general info the first time through.
  *
  */
 
     if ( debug == NULL && (debug = getenv(DWBDEBUG)) == NULL )
 	debug = "OFF";
 
     if ( strcmp(debug, "ON") == 0 ) {
 	if ( level == 0 ) {
 	    fprintf(stderr, "Environment variable: %s\n", DWBENV);
 	    fprintf(stderr, "Configuration file: %s\n", DWBCONFIG);
 	    fprintf(stderr, "Default home: %s\n", DWBHOME);
 	    if ( (home = DWBhome()) != NULL )
 		fprintf(stderr, "Current home: %s\n", home);
 	}   /* End if */
 
 	fprintf(stderr, "\n%s pathnames:\n", level == 0 ? "Original" : "Final");
 	for ( ; ptr->value != NULL || ptr->address != NULL; ptr++ ) {
 	    if ( (path = ptr->value) == NULL ) {
 		path = *ptr->address;
 		fprintf(stderr, " pointer: %s\n", path);
 	    } else fprintf(stderr, " array[%d]: %s\n", ptr->length, path);
 	    if ( level == 0 && *path == '/' )
 		fprintf(stderr, "  WARNING - absolute path\n");
 	}   /* End for */
     }	/* End if */
 
 }   /* End of DWBdebug */
 
 /*****************************************************************************/
 
 extern	char	*unsharp(char*);
 
 char *DWBhome(void)
 {
 
     FILE	*fp;
     char	*ptr;
     char	*path;
     int		len;
     char	buf[200];
     char	*home = NULL;
 
 /*
  *
  * Return the DWB home directory. Uses the last definition of DWBENV
  * (usually "DWBHOME") in file DWBCONFIG (perhaps /usr/lib/dwb3.4) or
  * the value assigned to the variable named by the DWBENV string in
  * the environment if DWBCONFIG doesn't exist or doesn't define DWBENV.
  * Skips the file lookup if DWBCONFIG can't be read. Returns NULL if
  * there's no home directory.
  *
  */
 
     if ( (fp = fopen(DWBCONFIG, "r")) != NULL ) {
 	len = strlen(DWBENV);
 	while ( fgets(buf, sizeof(buf), fp) != NULL ) {
 	    for ( ptr = buf; isspace((uchar)*ptr); ptr++ ) ;
 	    if ( strncmp(ptr, DWBENV, len) == 0 && *(ptr+len) == '=' ) {
 		path = ptr + len + 1;
 		for ( ptr = path; !isspace((uchar)*ptr) && *ptr != ';'; ptr++ ) ;
 		*ptr = '\0';
 		if ( home != NULL )
 		    free(home);
 		if ( (home = malloc(strlen(path)+1)) != NULL )
 		    strcpy(home, path);
 	    }	/* End if */
 	}   /* End while */
 	fclose(fp);
     }   /* End if */
 
     if ( home == NULL ) {
 	if ( (home = getenv(DWBENV)) == NULL ) {
 	    if ( (home = DWBHOME) == NULL || *home == '\0' || *home == ' ' )
 		home = NULL;
 	}   /* End if */
 	if ( home != NULL )
 		home = unsharp(home);
     }	/* End if */
 
     while (home && *home == '/' && *(home +1) == '/')	/* remove extra slashes */
 	home++;
     return(home);
 
 }   /* End of DWBhome */
 
 /*****************************************************************************/
 
 void DWBinit(char *prog, dwbinit *paths)
 {
 
     char	*prefix;
     char	*value;
     char	*path;
     int		plen;
     int		length;
     dwbinit	*opaths = paths;
 
 /*
  *
  * Adjust the pathnames listed in paths, using the home directory
  * returned by DWBhome(). Stops when it reaches an element that has
  * NULL address and value fields. Assumes pathnames are relative,
  * but changes everything. DWBdebug issues a warning if an original
  * path begins with a /.
  *
  * A non-NULL address refers to a pointer, which is reallocated and
  * then reinitialized. A NULL address implies a non-NULL value field
  * and describes a character array that we only reinitialize. The
  * length field for an array is the size of that array. The length
  * field of a pointer is an increment that's added to the length
  * required to store the new pathname string - should help when we
  * want to change character arrays to pointers in applications like
  * troff.
  *
  */
 
     if ( (prefix = DWBhome()) == NULL ) {
 	fprintf(stderr, "%s: no DWB home directory\n", prog);
 	exit(1);
     }	/* End if */
 
     DWBdebug(opaths, 0);
     plen = strlen(prefix);
 
     for ( ; paths->value != NULL || paths->address != NULL; paths++ ) {
 	if ( paths->address == NULL ) {
 	    length = 0;
 	    value = paths->value;
 	} else {
 	    length = paths->length;
 	    value = *paths->address;
 	}   /* End else */
 
 	length += plen + 1 + strlen(value);	/* +1 is for the '/' */
 
 	if ( (path = malloc(length+1)) == NULL ) {
 	    fprintf(stderr, "%s: can't allocate pathname memory\n", prog);
 	    exit(1);
 	}   /* End if */
 
 	if ( *value != '\0' ) {
 	    char *eop = prefix;
 	    while(*eop++)
 		;
 	    eop -= 2;
 	    if (*value != '/' && *eop != '/') {
 		sprintf(path, "%s/%s", prefix, value);
 	    } else if (*value == '/' && *eop == '/') {
 		value++;
 		sprintf(path, "%s%s", prefix, value);
 	    } else
 		sprintf(path, "%s%s", prefix, value);
 	} else
 		sprintf(path, "%s", prefix);
 
 	if ( paths->address == NULL ) {
 	    if ( strlen(path) >= paths->length ) {
 		fprintf(stderr, "%s: no room for %s\n", prog, path);
 		exit(1);
 	    }	/* End if */
 	    strcpy(paths->value, path);
 	    free(path);
 	} else *paths->address = path;
     }	/* End for */
 
     DWBdebug(opaths, 1);
 
 }   /* End of DWBinit */
 
 /*****************************************************************************/
 
 void DWBprefix( char *prog, char *path, int length)
 {
 
     char	*home;
     char	buf[512];
     int		len = strlen(DWBPREFIX);
 
 /*
  *
  * Replace a leading DWBPREFIX string in path by the current DWBhome().
  * Used by programs that pretend to handle .so requests. Assumes path
  * is an array with room for length characters. The implementation is
  * not great, but should be good enough for now. Also probably should
  * have DWBhome() only do the lookup once, and remember the value if
  * called again.
  * 
  */
 
     if ( strncmp(path, DWBPREFIX, len) == 0 ) {
 	if ( (home = DWBhome()) != NULL ) {
 	    if ( strlen(home) + strlen(path+len) < length ) {
 		sprintf(buf, "%s%s", home, path+len);
 		strcpy(path, buf);		/* assuming there's room in path */
 	    } else fprintf(stderr, "%s: no room to grow path %s", prog, path);
 	}   /* End if */
     }	/* End if */
 
 }   /* End of DWBprefix */
 
 /*****************************************************************************/