Fix new warnings from GCC 7

This addresses the new warning types -Wformat-truncation
-Wformat-overflow that are part of -Wall, via -Wformat, in GCC 7.

diff --git a/contrib/pg_standby/pg_standby.c b/contrib/pg_standby/pg_standby.c
index 9d766321e2fb57cad6e25c842391fcbb227d0e33..5d0cc286f97ffa25275ed7c51993e904f9852d99 100644 (file)
--- a/contrib/pg_standby/pg_standby.c
+++ b/contrib/pg_standby/pg_standby.c
@@ -57,7 +57,7 @@ char     *xlogFilePath;       /* where we are going to restore to */
 char      *nextWALFileName;    /* the file we need to get from archive */
 char      *restartWALFileName; /* the file from which we can restart restore */
 char      *priorWALFileName;   /* the file we need to get from archive */
-char       WALFilePath[MAXPGPATH];     /* the file path including archive */
+char       WALFilePath[MAXPGPATH * 2];     /* the file path including archive */
 char       restoreCommand[MAXPGPATH];  /* run this to restore */
 char       exclusiveCleanupFileName[MAXFNAMELEN];      /* the file we need to
                                                         * get from archive */
@@ -259,9 +259,9 @@ CustomizableCleanupPriorWALFiles(void)
                  strcmp(xlde->d_name + 8, exclusiveCleanupFileName + 8) < 0)
                {
 #ifdef WIN32
-                   snprintf(WALFilePath, MAXPGPATH, "%s\\%s", archiveLocation, xlde->d_name);
+                   snprintf(WALFilePath, sizeof(WALFilePath), "%s\\%s", archiveLocation, xlde->d_name);
 #else
-                   snprintf(WALFilePath, MAXPGPATH, "%s/%s", archiveLocation, xlde->d_name);
+                   snprintf(WALFilePath, sizeof(WALFilePath), "%s/%s", archiveLocation, xlde->d_name);
 #endif
 
                    if (debug)

diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index 3bd070474c28c0854de50cfbdfbd7d66b1f50552..257a477237822e527699b1a8aaac971b25125d4e 100644 (file)
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -1196,7 +1196,7 @@ CheckPointLogicalRewriteHeap(void)
    XLogRecPtr  redo;
    DIR        *mappings_dir;
    struct dirent *mapping_de;
-   char        path[MAXPGPATH];
+   char        path[MAXPGPATH + 20];
 
    /*
     * We start of with a minimum of the last redo pointer. No new decoding
@@ -1227,7 +1227,7 @@ CheckPointLogicalRewriteHeap(void)
            strcmp(mapping_de->d_name, "..") == 0)
            continue;
 
-       snprintf(path, MAXPGPATH, "pg_logical/mappings/%s", mapping_de->d_name);
+       snprintf(path, sizeof(path), "pg_logical/mappings/%s", mapping_de->d_name);
        if (lstat(path, &statbuf) == 0 && !S_ISREG(statbuf.st_mode))
            continue;
 

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index cd81c600fc759b42340c3ec83739c22cf0945b1b..3cc74bfe2ea351375193caf12ef1242b738ebd82 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -3888,7 +3888,7 @@ CleanupBackupHistory(void)
 {
    DIR        *xldir;
    struct dirent *xlde;
-   char        path[MAXPGPATH];
+   char        path[MAXPGPATH + sizeof(XLOGDIR)];
 
    xldir = AllocateDir(XLOGDIR);
    if (xldir == NULL)
@@ -3906,7 +3906,7 @@ CleanupBackupHistory(void)
                ereport(DEBUG2,
                (errmsg("removing transaction log backup history file \"%s\"",
                        xlde->d_name)));
-               snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlde->d_name);
+               snprintf(path, sizeof(path), XLOGDIR "/%s", xlde->d_name);
                unlink(path);
                XLogArchiveCleanup(xlde->d_name);
            }
@@ -10011,7 +10011,7 @@ do_pg_start_backup(const char *backupidstr, bool fast, TimeLineID *starttli_p,
        /* Collect information about all tablespaces */
        while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
        {
-           char        fullpath[MAXPGPATH];
+           char        fullpath[MAXPGPATH + 10];
            char        linkpath[MAXPGPATH];
            char       *relpath = NULL;
            int         rllen;

diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c
index 8f5e90be2a9c24f3d7fb5a665a28d8d176f34682..92958ea6b8bdb407d1323d2738680b1a54e97756 100644 (file)
--- a/src/backend/postmaster/pgstat.c
+++ b/src/backend/postmaster/pgstat.c
@@ -569,7 +569,7 @@ pgstat_reset_remove_files(const char *directory)
 {
    DIR        *dir;
    struct dirent *entry;
-   char        fname[MAXPGPATH];
+   char        fname[MAXPGPATH * 2];
 
    dir = AllocateDir(directory);
    while ((entry = ReadDir(dir, directory)) != NULL)
@@ -599,7 +599,7 @@ pgstat_reset_remove_files(const char *directory)
            strcmp(entry->d_name + nchars, "stat") != 0)
            continue;
 
-       snprintf(fname, MAXPGPATH, "%s/%s", directory,
+       snprintf(fname, sizeof(fname), "%s/%s", directory,
                 entry->d_name);
        unlink(fname);
    }

diff --git a/src/backend/replication/basebackup.c b/src/backend/replication/basebackup.c
index 624dea3b03a76f100dc926266612a0604a6f5054..b7d732a7d8f1db9fce2c0a2814fc10e6f7f12117 100644 (file)
--- a/src/backend/replication/basebackup.c
+++ b/src/backend/replication/basebackup.c
@@ -885,7 +885,7 @@ sendDir(char *path, int basepathlen, bool sizeonly, List *tablespaces,
 {
    DIR        *dir;
    struct dirent *de;
-   char        pathbuf[MAXPGPATH];
+   char        pathbuf[MAXPGPATH * 2];
    struct stat statbuf;
    int64       size = 0;
 
@@ -937,7 +937,7 @@ sendDir(char *path, int basepathlen, bool sizeonly, List *tablespaces,
                         "and should not be used. "
                         "Try taking another online backup.")));
 
-       snprintf(pathbuf, MAXPGPATH, "%s/%s", path, de->d_name);
+       snprintf(pathbuf, sizeof(pathbuf), "%s/%s", path, de->d_name);
 
        /* Skip postmaster.pid and postmaster.opts in the data directory */
        if (strcmp(pathbuf, "./postmaster.pid") == 0 ||

diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
index 6542fd4c8f70be6b79ccd3471aa2a41f3f4438a6..a924772964dca24d87ead7ff39ffdbe7b9633642 100644 (file)
--- a/src/backend/replication/logical/reorderbuffer.c
+++ b/src/backend/replication/logical/reorderbuffer.c
@@ -2515,7 +2515,7 @@ StartupReorderBuffer(void)
    while ((logical_de = ReadDir(logical_dir, "pg_replslot")) != NULL)
    {
        struct stat statbuf;
-       char        path[MAXPGPATH];
+       char        path[MAXPGPATH * 2 + 12];
 
        if (strcmp(logical_de->d_name, ".") == 0 ||
            strcmp(logical_de->d_name, "..") == 0)

diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
index b93f15d2b450d9a406eca0f76411cc1335ee7d86..981f3978323ea5cbac40e4a7ab25cac417c7bcbb 100644 (file)
--- a/src/backend/replication/logical/snapbuild.c
+++ b/src/backend/replication/logical/snapbuild.c
@@ -1814,7 +1814,7 @@ CheckPointSnapBuild(void)
    XLogRecPtr  redo;
    DIR        *snap_dir;
    struct dirent *snap_de;
-   char        path[MAXPGPATH];
+   char        path[MAXPGPATH + 21];
 
    /*
     * We start of with a minimum of the last redo pointer. No new replication
@@ -1841,7 +1841,7 @@ CheckPointSnapBuild(void)
            strcmp(snap_de->d_name, "..") == 0)
            continue;
 
-       snprintf(path, MAXPGPATH, "pg_logical/snapshots/%s", snap_de->d_name);
+       snprintf(path, sizeof(path), "pg_logical/snapshots/%s", snap_de->d_name);
 
        if (lstat(path, &statbuf) == 0 && !S_ISREG(statbuf.st_mode))
        {

diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index 12779029102070abe31609f5be3c34a37eda2e36..e37098faffb5c56b740437e0c4df773bce64f23c 100644 (file)
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -862,13 +862,13 @@ StartupReplicationSlots(void)
    while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL)
    {
        struct stat statbuf;
-       char        path[MAXPGPATH];
+       char        path[MAXPGPATH + 12];
 
        if (strcmp(replication_de->d_name, ".") == 0 ||
            strcmp(replication_de->d_name, "..") == 0)
            continue;
 
-       snprintf(path, MAXPGPATH, "pg_replslot/%s", replication_de->d_name);
+       snprintf(path, sizeof(path), "pg_replslot/%s", replication_de->d_name);
 
        /* we're only creating directories here, skip if it's not our's */
        if (lstat(path, &statbuf) == 0 && !S_ISDIR(statbuf.st_mode))
@@ -1100,7 +1100,7 @@ RestoreSlotFromDisk(const char *name)
 {
    ReplicationSlotOnDisk cp;
    int         i;
-   char        path[MAXPGPATH];
+   char        path[MAXPGPATH + 22];
    int         fd;
    bool        restored = false;
    int         readBytes;

diff --git a/src/backend/storage/file/copydir.c b/src/backend/storage/file/copydir.c
index 41b2c62bb6cfc1c6458bebb7056ae054f8e2f741..179b8966c9b1b4ebc767c8b86e1b3ba7651d7c2a 100644 (file)
--- a/src/backend/storage/file/copydir.c
+++ b/src/backend/storage/file/copydir.c
@@ -38,8 +38,8 @@ copydir(char *fromdir, char *todir, bool recurse)
 {
    DIR        *xldir;
    struct dirent *xlde;
-   char        fromfile[MAXPGPATH];
-   char        tofile[MAXPGPATH];
+   char        fromfile[MAXPGPATH * 2];
+   char        tofile[MAXPGPATH * 2];
 
    if (mkdir(todir, S_IRWXU) != 0)
        ereport(ERROR,
@@ -63,8 +63,8 @@ copydir(char *fromdir, char *todir, bool recurse)
            strcmp(xlde->d_name, "..") == 0)
            continue;
 
-       snprintf(fromfile, MAXPGPATH, "%s/%s", fromdir, xlde->d_name);
-       snprintf(tofile, MAXPGPATH, "%s/%s", todir, xlde->d_name);
+       snprintf(fromfile, sizeof(fromfile), "%s/%s", fromdir, xlde->d_name);
+       snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name);
 
        if (lstat(fromfile, &fst) < 0)
            ereport(ERROR,
@@ -103,7 +103,7 @@ copydir(char *fromdir, char *todir, bool recurse)
            strcmp(xlde->d_name, "..") == 0)
            continue;
 
-       snprintf(tofile, MAXPGPATH, "%s/%s", todir, xlde->d_name);
+       snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name);
 
        /*
         * We don't need to sync subdirectories here since the recursive

diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c
index 9d566a625b68fbea9ca9e40044cf5f49a0c2f52e..33955270b42be9f27d959bedbac74d45b17e8368 100644 (file)
--- a/src/backend/storage/file/fd.c
+++ b/src/backend/storage/file/fd.c
@@ -2454,7 +2454,7 @@ CleanupTempFiles(bool isProcExit)
 void
 RemovePgTempFiles(void)
 {
-   char        temp_path[MAXPGPATH];
+   char        temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)];
    DIR        *spc_dir;
    struct dirent *spc_de;
 
@@ -2502,7 +2502,7 @@ RemovePgTempFilesInDir(const char *tmpdirname)
 {
    DIR        *temp_dir;
    struct dirent *temp_de;
-   char        rm_path[MAXPGPATH];
+   char        rm_path[MAXPGPATH * 2];
 
    temp_dir = AllocateDir(tmpdirname);
    if (temp_dir == NULL)
@@ -2543,7 +2543,7 @@ RemovePgTempRelationFiles(const char *tsdirname)
 {
    DIR        *ts_dir;
    struct dirent *de;
-   char        dbspace_path[MAXPGPATH];
+   char        dbspace_path[MAXPGPATH * 2];
 
    ts_dir = AllocateDir(tsdirname);
    if (ts_dir == NULL)
@@ -2584,7 +2584,7 @@ RemovePgTempRelationFilesInDbspace(const char *dbspacedirname)
 {
    DIR        *dbspace_dir;
    struct dirent *de;
-   char        rm_path[MAXPGPATH];
+   char        rm_path[MAXPGPATH * 2];
 
    dbspace_dir = AllocateDir(dbspacedirname);
    if (dbspace_dir == NULL)
@@ -2771,7 +2771,7 @@ walkdir(const char *path,
 
    while ((de = ReadDirExtended(dir, path, elevel)) != NULL)
    {
-       char        subpath[MAXPGPATH];
+       char        subpath[MAXPGPATH * 2];
        struct stat fst;
        int         sret;
 
@@ -2781,7 +2781,7 @@ walkdir(const char *path,
            strcmp(de->d_name, "..") == 0)
            continue;
 
-       snprintf(subpath, MAXPGPATH, "%s/%s", path, de->d_name);
+       snprintf(subpath, sizeof(subpath), "%s/%s", path, de->d_name);
 
        if (process_symlinks)
            sret = stat(subpath, &fst);

diff --git a/src/backend/storage/file/reinit.c b/src/backend/storage/file/reinit.c
index b9b971b890777297638067270fb1a68aa2de4e39..39849d6ec84456eb313121ef9c1117a2fcc78876 100644 (file)
--- a/src/backend/storage/file/reinit.c
+++ b/src/backend/storage/file/reinit.c
@@ -48,7 +48,7 @@ typedef struct
 void
 ResetUnloggedRelations(int op)
 {
-   char        temp_path[MAXPGPATH];
+   char        temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
    DIR        *spc_dir;
    struct dirent *spc_de;
    MemoryContext tmpctx,
@@ -106,7 +106,7 @@ ResetUnloggedRelationsInTablespaceDir(const char *tsdirname, int op)
 {
    DIR        *ts_dir;
    struct dirent *de;
-   char        dbspace_path[MAXPGPATH];
+   char        dbspace_path[MAXPGPATH * 2];
 
    ts_dir = AllocateDir(tsdirname);
    if (ts_dir == NULL)
@@ -147,7 +147,7 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op)
 {
    DIR        *dbspace_dir;
    struct dirent *de;
-   char        rm_path[MAXPGPATH];
+   char        rm_path[MAXPGPATH * 2];
 
    /* Caller must specify at least one operation. */
    Assert((op & (UNLOGGED_RELATION_CLEANUP | UNLOGGED_RELATION_INIT)) != 0);
@@ -310,7 +310,7 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op)
            ForkNumber  forkNum;
            int         oidchars;
            char        oidbuf[OIDCHARS + 1];
-           char        srcpath[MAXPGPATH];
+           char        srcpath[MAXPGPATH * 2];
            char        dstpath[MAXPGPATH];
 
            /* Skip anything that doesn't look like a relation data file. */

diff --git a/src/backend/storage/ipc/dsm.c b/src/backend/storage/ipc/dsm.c
index b82ae05e15546da6f21820743add1c22badab14b..efc30d0a536dceae7cb2384808a386f494583b96 100644 (file)
--- a/src/backend/storage/ipc/dsm.c
+++ b/src/backend/storage/ipc/dsm.c
@@ -306,9 +306,9 @@ dsm_cleanup_for_mmap(void)
        if (strncmp(dent->d_name, PG_DYNSHMEM_MMAP_FILE_PREFIX,
                    strlen(PG_DYNSHMEM_MMAP_FILE_PREFIX)) == 0)
        {
-           char        buf[MAXPGPATH];
+           char        buf[MAXPGPATH + sizeof(PG_DYNSHMEM_DIR)];
 
-           snprintf(buf, MAXPGPATH, PG_DYNSHMEM_DIR "/%s", dent->d_name);
+           snprintf(buf, sizeof(buf), PG_DYNSHMEM_DIR "/%s", dent->d_name);
 
            elog(DEBUG2, "removing file \"%s\"", buf);
 

diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c
index 82311b4ca95a87a010b748eca6151defa9562725..035a1204f9675ef8fa7764225192f24c3a05038a 100644 (file)
--- a/src/backend/utils/adt/dbsize.c
+++ b/src/backend/utils/adt/dbsize.c
@@ -39,7 +39,7 @@ db_dir_size(const char *path)
    int64       dirsize = 0;
    struct dirent *direntry;
    DIR        *dirdesc;
-   char        filename[MAXPGPATH];
+   char        filename[MAXPGPATH * 2];
 
    dirdesc = AllocateDir(path);
 
@@ -56,7 +56,7 @@ db_dir_size(const char *path)
            strcmp(direntry->d_name, "..") == 0)
            continue;
 
-       snprintf(filename, MAXPGPATH, "%s/%s", path, direntry->d_name);
+       snprintf(filename, sizeof(filename), "%s/%s", path, direntry->d_name);
 
        if (stat(filename, &fst) < 0)
        {
@@ -84,7 +84,7 @@ calculate_database_size(Oid dbOid)
    DIR        *dirdesc;
    struct dirent *direntry;
    char        dirpath[MAXPGPATH];
-   char        pathname[MAXPGPATH];
+   char        pathname[MAXPGPATH + 12 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
    AclResult   aclresult;
 
    /* User must have connect privilege for target database */
@@ -96,7 +96,7 @@ calculate_database_size(Oid dbOid)
    /* Shared storage in pg_global is not counted */
 
    /* Include pg_default storage */
-   snprintf(pathname, MAXPGPATH, "base/%u", dbOid);
+   snprintf(pathname, sizeof(pathname), "base/%u", dbOid);
    totalsize = db_dir_size(pathname);
 
    /* Scan the non-default tablespaces */
@@ -116,7 +116,7 @@ calculate_database_size(Oid dbOid)
            strcmp(direntry->d_name, "..") == 0)
            continue;
 
-       snprintf(pathname, MAXPGPATH, "pg_tblspc/%s/%s/%u",
+       snprintf(pathname, sizeof(pathname), "pg_tblspc/%s/%s/%u",
                 direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid);
        totalsize += db_dir_size(pathname);
    }
@@ -164,7 +164,7 @@ static int64
 calculate_tablespace_size(Oid tblspcOid)
 {
    char        tblspcPath[MAXPGPATH];
-   char        pathname[MAXPGPATH];
+   char        pathname[MAXPGPATH * 2];
    int64       totalsize = 0;
    DIR        *dirdesc;
    struct dirent *direntry;
@@ -206,7 +206,7 @@ calculate_tablespace_size(Oid tblspcOid)
            strcmp(direntry->d_name, "..") == 0)
            continue;
 
-       snprintf(pathname, MAXPGPATH, "%s/%s", tblspcPath, direntry->d_name);
+       snprintf(pathname, sizeof(pathname), "%s/%s", tblspcPath, direntry->d_name);
 
        if (stat(pathname, &fst) < 0)
        {

diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index eede904f506e195bea7ec81a1581b41fb32be867..4ebe103c1ad1f57e0695c8761482679fe0bc7f18 100644 (file)
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -5306,7 +5306,7 @@ RelationCacheInitFileRemove(void)
    const char *tblspcdir = "pg_tblspc";
    DIR        *dir;
    struct dirent *de;
-   char        path[MAXPGPATH];
+   char        path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
 
    /*
     * We zap the shared cache file too.  In theory it can't get out of sync
@@ -5348,7 +5348,7 @@ RelationCacheInitFileRemoveInDir(const char *tblspcpath)
 {
    DIR        *dir;
    struct dirent *de;
-   char        initfilename[MAXPGPATH];
+   char        initfilename[MAXPGPATH * 2];
 
    /* Scan the tablespace directory to find per-database directories */
    dir = AllocateDir(tblspcpath);

diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index afe41ff645f88e8b08a732d664c9654ea04d6280..fc8d7362c60fd6a6410e3ce29fb0ab0168de5d89 100644 (file)
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -2206,7 +2206,7 @@ setup_formatted_log_time(void)
 {
    struct timeval tv;
    pg_time_t   stamp_time;
-   char        msbuf[8];
+   char        msbuf[13];
 
    gettimeofday(&tv, NULL);
    stamp_time = (pg_time_t) tv.tv_sec;

diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c
index a6264c7e2037aa88f63572a6659b340ee8851adb..f68a15b90b615c297e2ec3a0795b7adc0a1de92e 100644 (file)
--- a/src/backend/utils/time/snapmgr.c
+++ b/src/backend/utils/time/snapmgr.c
@@ -1417,7 +1417,7 @@ XactHasExportedSnapshots(void)
 void
 DeleteAllExportedSnapshotFiles(void)
 {
-   char        buf[MAXPGPATH];
+   char        buf[MAXPGPATH + sizeof(SNAPSHOT_EXPORT_DIR)];
    DIR        *s_dir;
    struct dirent *s_de;
 
@@ -1438,7 +1438,7 @@ DeleteAllExportedSnapshotFiles(void)
            strcmp(s_de->d_name, "..") == 0)
            continue;
 
-       snprintf(buf, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name);
+       snprintf(buf, sizeof(buf), SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name);
        /* Again, unlink failure is not worthy of FATAL */
        if (unlink(buf))
            elog(LOG, "could not unlink file \"%s\": %m", buf);

diff --git a/src/bin/initdb/initdb.c b/src/bin/initdb/initdb.c
index 12baae50f43adecc8ed625edcf6ef6ad8c92b478..118edf94559e461a096e204e95b49a42bd619d2e 100644 (file)
--- a/src/bin/initdb/initdb.c
+++ b/src/bin/initdb/initdb.c
@@ -556,7 +556,7 @@ walkdir(const char *path,
 
    while (errno = 0, (de = readdir(dir)) != NULL)
    {
-       char        subpath[MAXPGPATH];
+       char        subpath[MAXPGPATH * 2];
        struct stat fst;
        int         sret;
 
@@ -564,7 +564,7 @@ walkdir(const char *path,
            strcmp(de->d_name, "..") == 0)
            continue;
 
-       snprintf(subpath, MAXPGPATH, "%s/%s", path, de->d_name);
+       snprintf(subpath, sizeof(subpath), "%s/%s", path, de->d_name);
 
        if (process_symlinks)
            sret = stat(subpath, &fst);

diff --git a/src/bin/pg_archivecleanup/pg_archivecleanup.c b/src/bin/pg_archivecleanup/pg_archivecleanup.c
index c5569f32a336bec8d257c42af0054d5cf30ded08..44c40c03d4be275699ede1e35225593238527de6 100644 (file)
--- a/src/bin/pg_archivecleanup/pg_archivecleanup.c
+++ b/src/bin/pg_archivecleanup/pg_archivecleanup.c
@@ -32,7 +32,7 @@ char     *additional_ext = NULL;      /* Extension to remove from filenames */
 
 char      *archiveLocation;    /* where to find the archive? */
 char      *restartWALFileName; /* the file from which we can restart restore */
-char       WALFilePath[MAXPGPATH];     /* the file path including archive */
+char       WALFilePath[MAXPGPATH * 2];     /* the file path including archive */
 char       exclusiveCleanupFileName[MAXFNAMELEN];      /* the oldest file we
                                                         * want to remain in
                                                         * archive */
@@ -133,7 +133,7 @@ CleanupPriorWALFiles(void)
                 * extension that might have been chopped off before testing
                 * the sequence.
                 */
-               snprintf(WALFilePath, MAXPGPATH, "%s/%s",
+               snprintf(WALFilePath, sizeof(WALFilePath), "%s/%s",
                         archiveLocation, xlde->d_name);
 
                if (dryrun)

diff --git a/src/bin/pg_basebackup/pg_receivexlog.c b/src/bin/pg_basebackup/pg_receivexlog.c
index c4a60629acd32f7ac0556f6f97b5df27d3f0d2d5..82d78d0420df62a3ddddb660489bc80e062b4cbd 100644 (file)
--- a/src/bin/pg_basebackup/pg_receivexlog.c
+++ b/src/bin/pg_basebackup/pg_receivexlog.c
@@ -210,7 +210,7 @@ FindStreamingStart(uint32 *tli)
        if (!ispartial)
        {
            struct stat statbuf;
-           char        fullpath[MAXPGPATH];
+           char        fullpath[MAXPGPATH * 2];
 
            snprintf(fullpath, sizeof(fullpath), "%s/%s", basedir, dirent->d_name);
            if (stat(fullpath, &statbuf) != 0)

diff --git a/src/bin/pg_resetxlog/pg_resetxlog.c b/src/bin/pg_resetxlog/pg_resetxlog.c
index 75a9d2c89e5966484f9ee865993260f10a8696d7..1625549ae1bb435efcb838ba99c2885b26fede39 100644 (file)
--- a/src/bin/pg_resetxlog/pg_resetxlog.c
+++ b/src/bin/pg_resetxlog/pg_resetxlog.c
@@ -963,7 +963,7 @@ KillExistingXLOG(void)
 {
    DIR        *xldir;
    struct dirent *xlde;
-   char        path[MAXPGPATH];
+   char        path[MAXPGPATH + sizeof(XLOGDIR)];
 
    xldir = opendir(XLOGDIR);
    if (xldir == NULL)
@@ -978,7 +978,7 @@ KillExistingXLOG(void)
        if (IsXLogFileName(xlde->d_name) ||
            IsPartialXLogFileName(xlde->d_name))
        {
-           snprintf(path, MAXPGPATH, "%s/%s", XLOGDIR, xlde->d_name);
+           snprintf(path, sizeof(path), "%s/%s", XLOGDIR, xlde->d_name);
            if (unlink(path) < 0)
            {
                fprintf(stderr, _("%s: could not delete file \"%s\": %s\n"),
@@ -1010,11 +1010,11 @@ KillExistingXLOG(void)
 static void
 KillExistingArchiveStatus(void)
 {
+#define ARCHSTATDIR XLOGDIR "/archive_status"
+
    DIR        *xldir;
    struct dirent *xlde;
-   char        path[MAXPGPATH];
-
-#define ARCHSTATDIR XLOGDIR "/archive_status"
+   char        path[MAXPGPATH + sizeof(ARCHSTATDIR)];
 
    xldir = opendir(ARCHSTATDIR);
    if (xldir == NULL)
@@ -1032,7 +1032,7 @@ KillExistingArchiveStatus(void)
             strcmp(xlde->d_name + XLOG_FNAME_LEN, ".partial.ready") == 0 ||
             strcmp(xlde->d_name + XLOG_FNAME_LEN, ".partial.done") == 0))
        {
-           snprintf(path, MAXPGPATH, "%s/%s", ARCHSTATDIR, xlde->d_name);
+           snprintf(path, sizeof(path), "%s/%s", ARCHSTATDIR, xlde->d_name);
            if (unlink(path) < 0)
            {
                fprintf(stderr, _("%s: could not delete file \"%s\": %s\n"),

diff --git a/src/bin/pg_rewind/copy_fetch.c b/src/bin/pg_rewind/copy_fetch.c
index 224fad16f9f15f0bcd157e84d084e16deee5ed8f..168d040881c02211fe1ff82b7185e962bdcdd7ee 100644 (file)
--- a/src/bin/pg_rewind/copy_fetch.c
+++ b/src/bin/pg_rewind/copy_fetch.c
@@ -67,14 +67,14 @@ recurse_dir(const char *datadir, const char *parentpath,
    while (errno = 0, (xlde = readdir(xldir)) != NULL)
    {
        struct stat fst;
-       char        fullpath[MAXPGPATH];
-       char        path[MAXPGPATH];
+       char        fullpath[MAXPGPATH * 2];
+       char        path[MAXPGPATH * 2];
 
        if (strcmp(xlde->d_name, ".") == 0 ||
            strcmp(xlde->d_name, "..") == 0)
            continue;
 
-       snprintf(fullpath, MAXPGPATH, "%s/%s", fullparentpath, xlde->d_name);
+       snprintf(fullpath, sizeof(fullpath), "%s/%s", fullparentpath, xlde->d_name);
 
        if (lstat(fullpath, &fst) < 0)
        {
@@ -95,9 +95,9 @@ recurse_dir(const char *datadir, const char *parentpath,
        }
 
        if (parentpath)
-           snprintf(path, MAXPGPATH, "%s/%s", parentpath, xlde->d_name);
+           snprintf(path, sizeof(path), "%s/%s", parentpath, xlde->d_name);
        else
-           snprintf(path, MAXPGPATH, "%s", xlde->d_name);
+           snprintf(path, sizeof(path), "%s", xlde->d_name);
 
        if (S_ISREG(fst.st_mode))
            callback(path, FILE_TYPE_REGULAR, fst.st_size, NULL);

diff --git a/src/timezone/pgtz.c b/src/timezone/pgtz.c
index 2f0344ce39925610b45340e456aef2fbcbff77b0..149d9fb0afaa5fded7c4f45dac192549f4f23de2 100644 (file)
--- a/src/timezone/pgtz.c
+++ b/src/timezone/pgtz.c
@@ -437,7 +437,7 @@ pg_tzenumerate_next(pg_tzenum *dir)
    while (dir->depth >= 0)
    {
        struct dirent *direntry;
-       char        fullname[MAXPGPATH];
+       char        fullname[MAXPGPATH * 2];
        struct stat statbuf;
 
        direntry = ReadDir(dir->dirdesc[dir->depth], dir->dirname[dir->depth]);
@@ -454,7 +454,7 @@ pg_tzenumerate_next(pg_tzenum *dir)
        if (direntry->d_name[0] == '.')
            continue;
 
-       snprintf(fullname, MAXPGPATH, "%s/%s",
+       snprintf(fullname, sizeof(fullname), "%s/%s",
                 dir->dirname[dir->depth], direntry->d_name);
        if (stat(fullname, &statbuf) != 0)
            ereport(ERROR,