sed: Can't open /usr/web/plan9/sources.html /* * * 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 */ /*****************************************************************************/ sed: Can't open /usr/web/plan9/sources.html