/*  * This file is part of the UCB release of Plan 9. It is subject to the license * terms in the LICENSE file found in the top-level directory of this * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No * part of the UCB release of Plan 9, including this file, may be copied, * modified, propagated, or distributed except according to the terms contained * in the LICENSE file. */ /* * * 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 <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 */ /*****************************************************************************/ 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(*ptr); ptr++ ) ;	    if ( strncmp(ptr, DWBENV, len) == 0 && *(ptr+len) == '=' ) {		path = ptr + len + 1;		for ( ptr = path; !isspace(*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 */    }	/* 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 */ /*****************************************************************************/