conffiles.c

Go to the documentation of this file.

/*--------------------------------------------------------------------
 * conffiles.c
 *
 * Utilities related to the handling of configuration files.
 *
 * This file contains some generic tools to work on configuration files
 * used by PostgreSQL, be they related to GUCs or authentication.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/backend/utils/misc/conffiles.c
 *
 *--------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include <dirent.h>
 
#include "common/file_utils.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "utils/conffiles.h"
 
/*
 * AbsoluteConfigLocation
 *
 * Given a configuration file or directory location that may be a relative
 * path, return an absolute one.  We consider the location to be relative to
 * the directory holding the calling file, or to DataDir if no calling file.
 */
char *
AbsoluteConfigLocation(const char *location, const char *calling_file)
{
    if (is_absolute_path(location))
        return pstrdup(location);
    else
    {
        char        abs_path[MAXPGPATH];
 
        if (calling_file != NULL)
        {
            strlcpy(abs_path, calling_file, sizeof(abs_path));
            get_parent_directory(abs_path);
            join_path_components(abs_path, abs_path, location);
            canonicalize_path(abs_path);
        }
        else
        {
            Assert(DataDir);
            join_path_components(abs_path, DataDir, location);
            canonicalize_path(abs_path);
        }
        return pstrdup(abs_path);
    }
}
 
 
/*
 * GetConfFilesInDir
 *
 * Returns the list of config files located in a directory, in alphabetical
 * order.  On error, returns NULL with details about the error stored in
 * "err_msg".
 */
char      **
GetConfFilesInDir(const char *includedir, const char *calling_file,
                  int elevel, int *num_filenames, char **err_msg)
{
    char       *directory;
    DIR        *d;
    struct dirent *de;
    char      **filenames = NULL;
    int         size_filenames;
 
    /*
     * Reject directory name that is all-blank (including empty), as that
     * leads to confusion --- we'd read the containing directory, typically
     * resulting in recursive inclusion of the same file(s).
     */
    if (strspn(includedir, " \t\r\n") == strlen(includedir))
    {
        ereport(elevel,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("empty configuration directory name: \"%s\"",
                        includedir)));
        *err_msg = "empty configuration directory name";
        return NULL;
    }
 
    directory = AbsoluteConfigLocation(includedir, calling_file);
    d = AllocateDir(directory);
    if (d == NULL)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not open configuration directory \"%s\": %m",
                        directory)));
        *err_msg = psprintf("could not open directory \"%s\"", directory);
        goto cleanup;
    }
 
    /*
     * Read the directory and put the filenames in an array, so we can sort
     * them prior to caller processing the contents.
     */
    size_filenames = 32;
    filenames = (char **) palloc(size_filenames * sizeof(char *));
    *num_filenames = 0;
 
    while ((de = ReadDir(d, directory)) != NULL)
    {
        PGFileType  de_type;
        char        filename[MAXPGPATH];
 
        /*
         * Only parse files with names ending in ".conf".  Explicitly reject
         * files starting with ".".  This excludes things like "." and "..",
         * as well as typical hidden files, backup files, and editor debris.
         */
        if (strlen(de->d_name) < 6)
            continue;
        if (de->d_name[0] == '.')
            continue;
        if (strcmp(de->d_name + strlen(de->d_name) - 5, ".conf") != 0)
            continue;
 
        join_path_components(filename, directory, de->d_name);
        canonicalize_path(filename);
        de_type = get_dirent_type(filename, de, true, elevel);
        if (de_type == PGFILETYPE_ERROR)
        {
            *err_msg = psprintf("could not stat file \"%s\"", filename);
            pfree(filenames);
            filenames = NULL;
            goto cleanup;
        }
        else if (de_type != PGFILETYPE_DIR)
        {
            /* Add file to array, increasing its size in blocks of 32 */
            if (*num_filenames >= size_filenames)
            {
                size_filenames += 32;
                filenames = (char **) repalloc(filenames,
                                               size_filenames * sizeof(char *));
            }
            filenames[*num_filenames] = pstrdup(filename);
            (*num_filenames)++;
        }
    }
 
    /* Sort the files by name before leaving */
    if (*num_filenames > 0)
        qsort(filenames, *num_filenames, sizeof(char *), pg_qsort_strcmp);
 
cleanup:
    if (d)
        FreeDir(d);
    pfree(directory);
    return filenames;
}