Rev 2 | Blame | Compare with Previous | Last modification | View Log | RSS feed
/*
*
* 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 */
/*****************************************************************************/