file.c

Go to the documentation of this file.

/*
 
  $Id: file.c 23583 2019-07-12 06:17:23Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
#include <unistd.h>
#include <stdlib.h>
 
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <ctype.h>
 
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/wait.h>
 
#include <dirent.h>
#include <regex.h>
 
#include "genC.h"
#include "misc.h"
 
/* FC 2015-07-20: yuk, moved out to prevent an include cycle dependency
 * #include "properties.h"
 */
extern bool get_bool_property(const string);
extern char* get_string_property(const char*);
 
/* @return a file descriptor.
 */
FILE * check_fopen(const char * file, const char * mode)
{
  FILE * fd = fopen(file, mode);
  if (fd==(FILE*)NULL)
  {
    pips_user_warning("fopen failed on file \"%s\" (mode \"%s\")\n%s\n",
                      file, mode, strerror(errno));
  }
  return fd;
}
 
FILE * safe_fopen(const char *filename, const char *what)
{
  FILE * f;
  if((f = fopen( filename, what)) == (FILE *) NULL) {
    pips_internal_error("fopen failed on file %s\n%s",
                        filename, strerror(errno));
  }
  return f;
}
 
int safe_fclose(FILE * stream, const char *filename)
{
  if(fclose(stream) == EOF) {
    if(errno==ENOSPC)
            pips_user_irrecoverable_error("fclose failed on file %s (%s)\n",
                                    filename, strerror(errno));
    else
            pips_internal_error("fclose failed on file %s (%s)",
                          filename, strerror(errno));
  }
  return 0;
}
 
int safe_fflush(FILE * stream, char *filename)
{
  if (fflush(stream) == EOF)
    pips_internal_error("fflush failed on file %s (%s)",
                        filename,
                        strerror(errno));
  return 0;
}
 
FILE * safe_freopen(char *filename, char *what, FILE * stream)
{
  FILE *f;
 
  if((f = freopen( filename, what, stream)) == (FILE *) NULL) {
    pips_internal_error("freopen failed on file %s (%s)",
                        filename,
                        strerror(errno));
  }
  return f;
}
 
int
safe_fseek(FILE * stream, long int offset, int wherefrom, char *filename)
{
    if( fseek( stream, offset, wherefrom) != 0) {
        pips_internal_error("fseek failed on file %s (%s)",
                   filename,
                   strerror(errno));
    }
    return(0);
}
 
long int
safe_ftell(FILE * stream, char *filename)
{
    long int pt;
    pt = ftell( stream);
    if((pt == -1L) && (errno != 0)) {
        pips_internal_error("ftell failed on file %s (%s)",
                   filename,
                   strerror(errno));
    }
    return(pt);
}
 
void
safe_rewind(FILE * stream, char *filename)
{
    rewind( stream );
    if(errno != 0) {
        pips_internal_error("rewind failed on file %s (%s)",
                   filename,
                   strerror(errno));
    }
}
 
int
safe_fgetc(FILE * stream, char *filename)
{
    int value;
    if((value = fgetc( stream)) == EOF) {
        pips_internal_error("fgetc failed on file %s (%s)",
                   filename, strerror(errno));
    }
    return(value);
}
 
int
safe_getc(FILE * stream, char *filename)
{
    int value;
    if((value = getc( stream)) == EOF ) {
        pips_internal_error("getc failed on file %s (%s)",
                   filename,
                   strerror(errno));
    }
    return(value);
}
 
char*
safe_fgets(char* s, int n, FILE* stream, char* filename)
{
  if (fgets(s, n, stream) == (char *) NULL) {
    pips_internal_error("gets failed on file %s (%s)",
                        filename, strerror(errno));
  }
  return s;
}
 
int safe_fputc( c, stream, filename)
char c;
FILE * stream;
char * filename;
{
    if(fputc( c, stream) == EOF) {
        pips_internal_error("fputc failed on file %s (%s)",
                   filename, strerror(errno));
    }
    return(c);
}
 
int safe_putc( c, stream, filename)
char c;
FILE * stream;
char * filename;
{
    if(putc( c, stream) == EOF) {
        pips_internal_error("putc failed on file %s (%s)",
                   filename, strerror(errno));
    }
    return(c);
}
 
int safe_fputs( s, stream, filename)
char * s, * filename;
FILE * stream;
{
    if(fputs( s, stream) == EOF) {
        pips_internal_error("fputs failed on file %s (%s)",
                   filename, strerror(errno));
    }
    return(1);
}
 
int safe_fread( ptr, element_size, count, stream, filename)
char * ptr, * filename;
int element_size;
int count;
FILE * stream;
{
    if(((int)fread(ptr, element_size, count, stream)) != count) {
        pips_internal_error("fread failed on file %s (%s)",
                   filename, strerror(errno));
    }
    return(count);
}
 
int safe_fwrite( ptr, element_size, count, stream, filename)
char * ptr, * filename;
int element_size;
int count;
FILE * stream;
{
    if(((int)fwrite(ptr, element_size, count, stream)) != count) {
        pips_internal_error("fwrite failed on file %s (%s)",
                   filename,
                   strerror(errno));
    }
    return(count);
}
 
/* returns a sorted arg list of files matching regular expression re
  in directory 'dir' and with file_name_predicate() returning true on
  the file name (for example use directory_exists_p to select
  directories, of file_exists_p to select regular files).  re has the
  ed syntax.
 
  Return 0 on success, -1 on directory openning error.
  */
int
safe_list_files_in_directory(
    gen_array_t files, /* an allocated array */
    string dir, /* the directory we're interested in */
    string re, /* regular expression */
    bool (*file_name_predicate)(const char *) /* condition to list a file */)
{
    DIR * dirp;
    struct dirent * dp;
    int index = 0;
 
    pips_assert("some dir", strcmp(dir, "") != 0);
 
    dirp = opendir(dir);
 
    if (dirp != NULL)
    {
        regex_t re_compiled;
 
        if (regcomp(&re_compiled, re, REG_ICASE))
            pips_user_error("regcomp() failed to compile \"%s\".\n", re);
 
        while((dp = readdir(dirp)) != NULL) {
            if (!regexec(&re_compiled, dp->d_name, 0, NULL, 0))
            {
                char * full_file_name =
                    strdup(concatenate(dir, "/", dp->d_name, NULL));
                if (file_name_predicate(full_file_name))
                    gen_array_dupaddto(files, index++, dp->d_name);
                free(full_file_name);
            }
        }
 
        regfree(&re_compiled);
 
        closedir(dirp);
    }
    else
        return -1;
 
   gen_array_sort(files);
   return 0;
}
 
 
/* The same as the previous safe_list_files_in_directory() but with no
   return code and a call to user error if it cannot open the
   directory.
   */
void
list_files_in_directory(
  gen_array_t files,
  string dir,
  string re,
  bool (* file_name_predicate)(const char *))
{
  int return_code =
    safe_list_files_in_directory(files, dir, re, file_name_predicate);
 
    if (return_code == -1)
      pips_user_error("opendir() failed on directory \"%s\", %s.\n",
                      dir, strerror(errno));
}
 
bool
directory_exists_p(const char * name)
{
    struct stat buf;
    return (stat(name, &buf) == 0) && S_ISDIR(buf.st_mode);
}
 
bool
file_exists_p(const char * name)
{
    struct stat buf;
    return (stat(name, &buf) == 0) && S_ISREG(buf.st_mode);
}
 
#define to_escape(c) \
  !isalnum(c) && c != '_' && c != '/' && c != '.'
 
/* protect a string, for example for use in a system call
 * list of non escaped characters in the macro above.
 */
char *
strescape (const char *source)
{
  size_t new_size = 1; // for \0
  for (const char *iter=source; *iter; ++iter,++new_size)
    if (to_escape(*iter)) ++new_size;
  char *escaped = malloc(sizeof(char)*new_size);
  char *eiter = escaped;
  for (const char *iter=source; *iter; ++iter,++eiter) {
    if (to_escape(*iter)) *eiter++ = '\\';
    *eiter = *iter;
  }
    *eiter=0;
    return escaped;
}
 
#define COLON ':'
/* Returns the allocated nth path from colon-separated path string.
 
   @param path_list the string that contains a colon-separated path
 
   @param n the n-th instance to extract
 
   @return an allocated string with the n-th part name
 
   If the path is empty or if n is out-of-bound, NULL is returned.
   The resulting string is *not*escaped, and can contain spaces
*/
string
nth_path(const char * path_list, int n)
{
  int len;
 
  if (path_list == NULL)
    return NULL;
 
  /* Find the n-th part: */
  while (*path_list && n > 0)
    if (*path_list++ == COLON)
      n--;
 
  if (!*path_list)
    /* Out-of-bound... */
    return NULL;
 
  /* Compute the length up to the COLON or the end of string: */
  for(len = 0; path_list[len] && path_list[len] != COLON; len++)
    ;
 
  char *unescaped =  strndup(path_list, len);
  return unescaped;
}
 
 
static char *
relative_name_if_necessary(const char * name)
{
    if (name[0]=='/' || name[0]=='.') return strdup(name);
    else return strdup(concatenate("./", name, NULL));
}
 
/* returns an allocated string pointing to the file, possibly
 * with an additional path taken from colon-separated dir_path.
 * returns NULL if no file was found.
 */
char *
find_file_in_directories(const char *file_name, const char *dir_path)
{
    char *path;
    int n=0;
    pips_assert("some file name", file_name);
 
    if (file_exists_p(file_name))
        return relative_name_if_necessary(file_name);
 
    if (!dir_path || file_name[0]=='/')
        return (string) NULL;
 
    /* looks for the file with an additional path ahead.
     */
    while ((path=nth_path(dir_path, n++)))
    {
        char *name = strdup(concatenate(path, "/", file_name, NULL)),
          *res=NULL;
        free(path);
        if (file_exists_p(name))
            res = relative_name_if_necessary(name);
        free(name);
        if (res) return res;
    }
 
    return (string) NULL;
}
 
bool
file_readable_p(char * name)
{
    struct stat buf;
    return !stat(name, &buf) && (S_IRUSR & buf.st_mode);
}
 
bool
create_directory(char *name)
{
  bool success = true;
 
  if (directory_exists_p(name)) {
    pips_internal_error("existing directory: %s", name);
  }
 
  if (mkdir(name, 0777) == -1) {
    pips_user_warning("cannot create directory: %s (%s)\n",
                      name, strerror(errno));
    success = false;
  }
 
  return success;
}
 
bool
purge_directory(char *name)
{
  bool success = true;
 
  if (directory_exists_p(name)) {
    if(system(concatenate("/bin/rm -r ", name, (char*) NULL))) {
            // FI: this warning should be emitted by a higher-level routine!
      pips_user_warning("cannot purge directory %s. Check owner rights\n", name);
      success = false;
    }
    else {
            success = true;
    }
  }
  else {
    // Well, it's purged if it does not exist...
    success = true;
  }
 
  return success;
}
 
#if !defined(PATH_MAX)
#if defined(_POSIX_PATH_MAX)
#define PATH_MAX _POSIX_PATH_MAX
#else
#define PATH_MAX 255
#endif
#endif
 
/* returns the current working directory name.
 */
char *
get_cwd(void)
{
    static char cwd[PATH_MAX]; /* argh */
    cwd[PATH_MAX-1] = '\0';
    return getcwd(cwd, PATH_MAX);
}
 
/* returns the allocated line read, whatever its length.
 * returns NULL on EOF. also some asserts. FC 09/97.
 */
char *
safe_readline(FILE * file)
{
    int i=0, size = 20, c;
    char * buf = (char*) malloc(sizeof(char)*size), * res;
    pips_assert("malloc ok", buf);
    while((c=getc(file)) && c!=EOF && c!='\n')
    {
        if (i==size-1) /* larger for trailing '\0' */
        {
            size+=20; buf = (char*) realloc((char*) buf, sizeof(char)*size);
            pips_assert("realloc ok", buf);
        }
        buf[i++] = (char) c;
    }
    if (c==EOF && i==0) { res = NULL; free(buf); }
    else { buf[i++] = '\0'; res = strdup(buf); free(buf); }
    return res;
}
 
/* Assumes "fn" is the name of a text file, opens it, and returns
 * its nth line (starting with 1) in a newly allocated buffer,
 * whatever the line length. Returns NULL if it does not exist.
 *
 * This function is used by the PIPS preprocessor and its parsers to
 * print out the line where an error has been detected.
 */
string safe_read_nth_line(string fn, int n)
{
  FILE * fd = safe_fopen(fn, "r");
  int i = 0;
#define MAX_INPUT_LINE_SIZE (200)
  char current_line[MAX_INPUT_LINE_SIZE];
  // Skip n-1 lines
  for(i=0; i<n-1; i++)
    safe_fgets(current_line, MAX_INPUT_LINE_SIZE, fd, fn);
  string nth_line = safe_readline(fd);
  safe_fclose(fd, fn);
  return nth_line;
}
 
/* return lines f-l from file fn as a string
 */
string safe_get_line_interval(const string fn, int f, int l)
{
  pips_assert("positive lines", 1 <= f && 1 <= l);
 
  if (l < f) {
    // ooops, empty interval...
    // TODO: generate an internal error instead
    // however there are some impact on the validation...
    string msg;
    asprintf(&msg, "<empty interval on \"%s\": %d-%d>\n", fn, f, l);
    return msg;
  }
 
  FILE * fd = safe_fopen(fn, "r");
  string_buffer sb = string_buffer_make(true);
 
  // skip first lines
  int i;
  for (i = 1; i < f ; i++) {
    char * line = safe_readline(fd);
    pips_assert("expecting a line", line != NULL);
    free(line);
  }
 
  // keep next lines, although without preprocessor stuff
  for (i = f; i <= l; i++)
  {
    char * line = safe_readline(fd);
    // pips_assert("expecting a line", line != NULL);
    if (line == NULL) break;
 
    // ??? skip preprocessor #... lines?
    // I'm not sure that it really works (FC)
    char * c = line;
    while (*c && (*c == ' ' || *c == '\t')) c++;
    if (*c == '#') // ??? preprocessor line?
      i--;
    else {
      string_buffer_append(sb, line);
      string_buffer_append(sb, "\n");
    }
 
    free(line);
  }
 
  // we are done
  safe_fclose(fd, fn);
 
  string extract = string_buffer_to_string(sb);
  string_buffer_free(&sb);
 
  return extract;
}
 
/* Assumes "fn" is the name of a text file, opens it, and copies the
 * lines whose number belongs to [f..l] into file descriptor "out",
 * except if they have been generated by a C preprocessor. Line
 * starting with '#' are counted but not copied.
 *
 * This function is used by the PIPS preprocessor and its parsers to
 * print out the lines where an error has been detected.
 */
void safe_copy_line_interval(string fn, int f, int l, FILE * out)
{
  FILE * fd = safe_fopen(fn, "r");
  int i = 0;
#define MAX_INPUT_LINE_SIZE (200)
  char current_line[MAX_INPUT_LINE_SIZE];
 
  pips_assert("The interval is strictly positive and non empty",
              f>=1 && l>=f);
 
  // Skip f-1 lines
  for(i=0; i<f-1; i++)
    safe_fgets(current_line, MAX_INPUT_LINE_SIZE, fd, fn);
 
  // Copy l-f+1 lines
  int c = l - f + 1;
  while(c>0) {
    int n = fgetc(fd);
    if(n==EOF)
      break;
    else {
      if((char) n == '#') {
        /* Do not reproduce this line as it was generated by an
           external preprocessor whose behavior is not controlled */
        while(c>0) {
          n = fgetc(fd);
          if(n==EOF)
            c = -1; // stop
          else if((char) n == '\n') {
            c--; // One useless line has been read
            break;
          }
        }
      }
      else {
        fputc(n, out);
        if((char) n == '\n')
          c--;
      }
    }
  }
 
  safe_fclose(fd, fn);
}
 
/* returns the file as an allocated string.
 * \n is dropped at the time.
 */
char *
safe_readfile(FILE * file)
{
    char * line, * buf=NULL;
    while ((line=safe_readline(file)))
    {
        if (buf)
        {
            buf = (char*)
                realloc(buf, sizeof(char)*(strlen(buf)+strlen(line)+2));
            strcat(buf, " ");
            strcat(buf, line);
            free(line);
        }
        else buf = line;
    }
    return buf;
}
 
void
safe_cat(FILE * out, FILE * in)
{
    int c;
    while ((c=getc(in))!=EOF)
      if (putc(c, out)==EOF)
        pips_internal_error("cat failed");
    safe_fflush(out, "<probably stdout>");
}
 
void
safe_append(
    FILE * out        /* where to output the file content */,
    char *file        /* the content of which is appended */,
    int margin        /* number of spaces for shifting */ ,
    bool but_comments /* do not shift F77 comment lines */)
{
    FILE * in = safe_fopen(file, "r");
    bool first = true;
    int c, i;
    while ((c=getc(in))!=EOF)
    {
        if (first && (!but_comments || (c!='C' && c!='c' && c!='*' && c!='!')))
        {
            for (i=0; i<margin; i++)
                if (putc(' ', out)==EOF)
                    pips_internal_error("append failed");
            first = false;
        }
        if (c=='\n')
            first = true;
        if (putc(c, out)==EOF)
            pips_internal_error("append failed");
    }
    safe_fclose(in, file);
}
 
void
safe_copy(char *source, char *target)
{
    FILE * in, * out;
    in = safe_fopen(source, "r");
    out = safe_fopen(target, "w");
    safe_cat(out, in);
    safe_fclose(out, target);
    safe_fclose(in, source);
}
 
/* Display a file through $PIPS_MORE (or $PAGER) if stdout is a TTY,
   on stdout otherwise.
 
   Return false if the file couldn't be displayed.
 */
int
safe_display(char *fname)
{
        if (!file_exists_p(fname))
        {
                pips_user_error("View file \"%s\" not found\n", fname);
                return 0;
        }
 
        if (isatty(fileno(stdout)))
        {
                int pgpid = fork();
                if (pgpid)
                {
                        int status;
                        waitpid(pgpid, &status, 0);
                        return WIFEXITED(status) && WEXITSTATUS(status) == 0;
                }
                else
                {
                        char *pager = getenv("PIPS_MORE");
                        if (!pager)
                                pager = getenv("PAGER");
                        if (!pager)
                                pager = "more";
                        execlp(pager, pager, fname, NULL);
                        pips_internal_error("running %s %s: %s",
                                            pager, fname, strerror(errno));
                        exit(127);
                }
        }
        else
        {
                FILE * in = safe_fopen(fname, "r");
                safe_cat(stdout, in);
                safe_fclose(in, fname);
                return 1;
        }
}
 
␌
/* Some OS do not define basename and dirname. Others like DEC OSF1
   do. So define them and use another name for them:
 
   /some/path/to/file.suffix -> file
 
   This may create conflicting file names, when the same source
   filename is used in different subdirectory as in:
 
   create foo mod.c src/mod.c src/init/mod.c src/close/mod.c
 
   To avoid the problem a larger part of the access path should be
   preserved. This can be done by substituting / by another character.
 */
char * pips_filename(char *fullpath, char *suffix, bool short_p)
{
    int len = strlen(fullpath)-1, i, j;
    char *result;
 
    if (suffix) /* Drop the suffix */
    {
      int ls = strlen(suffix) - 1, le = len;
      while (suffix[ls] == fullpath[le]) {
        ls--;
        le--;
        if (ls < 0 || le < 0)
          break;
      }
      if (ls < 0) /* ok */
        len = le;
    }
 
    if(short_p) {
      /* Keep the basename only */
      for (i=len; i>=0; i--) if (fullpath[i]=='/') break;
      /* fullpath[i+1:len] */
      result = (char*) malloc(sizeof(char)*(len-i+1));
      for (i++, j=0; i<=len; i++, j++)
        result[j] = fullpath[i];
      result[j++] = '\0';
    }
    else {
    /* Or substitute slashes by a neutral character */
      char * cc;
 
      if(fullpath[0]=='.' && fullpath[1]=='/')
        result = strndup(fullpath+2, len-1);
      else
        result = strndup(fullpath, len+1);
 
 
#define SLASH_SUBSTITUTION_CHARACTER '_'
 
      for(cc=result; *cc!='\000'; cc++) {
        if(*cc=='/')
          *cc = SLASH_SUBSTITUTION_CHARACTER;
      }
    }
    return result;
}
 
char * pips_basename(char *fullpath, char *suffix)
{
  return pips_filename(fullpath, suffix, true);
}
 
/* The source file name access path is shortened or not depending on
   the property. It is shorten if the name conflicts are not managed. */
char * pips_initial_filename(char *fullpath, char *suffix)
{
  return pips_filename(fullpath, suffix,
                       !get_bool_property("PREPROCESSOR_FILE_NAME_CONFLICT_HANDLING"));
}
 
/* /some/path/to/file.suffix -> /some/path/to
 */
char * pips_dirname(char *fullpath)
{
    char *result = strdup(fullpath);
    int len = strlen(result);
    while (result[--len]!='/' && len>=0);
    result[len] = '\0';
    return result;
}
 
␌
/* Delete the given file.
 
   Throw a pips_internal_error() if it fails.
*/
void
safe_unlink(const char *file_name)
{
  if (unlink(file_name))
  {
    perror("[safe_unlink] ");
    pips_internal_error("unlink %s failed", file_name);
  }
}
 
void
safe_symlink(const char *topath, const char *frompath)
{
  if (symlink(topath, frompath))
  {
    perror("[safe_symlink] ");
    pips_internal_error("symlink(%s, %s) failed", topath, frompath);
  }
}
 
 
/* Create a hard link to topath. That means that the file is accessible
   with the new name frompath too.
 
   Throw a pips_internal_error() if it fails.
*/
void
safe_link(const char *topath, const char *frompath)
{
  if (link(frompath, topath))
  {
    perror("[safe_link] ");
    pips_internal_error("link(%s,%s) failed", frompath, topath);
  }
}
 
/* attempt shell substitutions to what. returns NULL on errors.
 */
char *
safe_system_output(char * what)
{
    char * result;
    FILE * in;
 
    in = popen(what, "r");
 
    if (in==NULL) {
        perror("[safe_system_output] ");
        pips_internal_error("popen failed: %s", what);
    }
 
    result = safe_readfile(in);
 
    if (pclose(in)) {
        /* on failures, do not stop it anyway...
         */
        perror("[safe_system_output] ");
        pips_user_warning("\n pclose failed: %s\n", what);
        if (result) free(result), result = NULL;
    }
 
    return result;
}
 
/* returns what after variable, command and file substitutions.
 * the returned string is newly allocated. it's NULL on errors.
 */
char *
safe_system_substitute(char * what)
{
    return safe_system_output(concatenate("echo ", what, NULL));
}
 
/* SunOS forgets to declare this one.
 */
/* extern char * mktemp(char *); */
 
/* @return a new temporary file name, starting with "prefix".
 * the name is freshly allocated.
 *
 * FI: mkstemp() is being deprecated and it returns an integer, usable as
 * file descriptor, not a character string.
 *
 */
char * safe_new_tmp_file(char * prefix)
{
  string name = strdup(concatenate(prefix, ".XXXXXX", NULL));
  int desc = mkstemp(name);
  pips_assert("could create temporary name", desc!=-1);
  return name;
}
 
/* utility to open configuration file, (read only!)
 * its name can be found using various ways
 * property and env can be NULL (and ignored)
 * if the file if not found a pips_error is generated
 * canonical_name should be a file name, not a path
 */
#define DEFAULT_CONFIG_DIR "etc"
#define CONFIG_DEFAULT_RIGHT "r"
FILE *
fopen_config(const char* canonical_name,
             const char* cproperty,
             const char* cenv)
{
  FILE * fconf;
 
  // try various combinaison :
  // pips property
  if (cproperty) {
    const string sproperty = get_string_property(cproperty);
    if (sproperty && (fconf = fopen(sproperty, CONFIG_DEFAULT_RIGHT)))
      return fconf;
  }
 
  // then pips env var
  if (cenv) {
    string senv = getenv(cenv);
    if (senv && (fconf = fopen(senv, CONFIG_DEFAULT_RIGHT)))
      return fconf;
  }
 
  // then default, with PIPS_ROOT if set
  string pipsenv = getenv("PIPS_ROOT");
  string sdefault;
  if(pipsenv)
    sdefault =
      concatenate(pipsenv,"/" DEFAULT_CONFIG_DIR "/" , canonical_name, NULL);
  else
    sdefault = concatenate(CONFIG_DIR "/", canonical_name, NULL);
 
  return safe_fopen(sdefault, CONFIG_DEFAULT_RIGHT);
}