Further tweaking of the readfile() function in pg_ctl.

Don't leak a file descriptor if the file is empty or we can't read its size.

Expect there to be a newline at the end of the last line, too. If there
isn't, ignore anything after the last newline. This makes it a tiny bit
more robust in case the file is appended to concurrently, so that we don't
return the last line if it hasn't been fully written yet. And this makes
the code a bit less obscure, anyway. Per Tom Lane's suggestion.

Backpatch to all supported branches.

diff --git a/src/bin/pg_ctl/pg_ctl.c b/src/bin/pg_ctl/pg_ctl.c
index 7f1932e5f6f57a9b1a0f7a2d0d742cb0b747eefe..f1f332151fc820fe8b98f7471438c006d7ecd5d6 100644 (file)
--- a/src/bin/pg_ctl/pg_ctl.c
+++ b/src/bin/pg_ctl/pg_ctl.c
@@ -324,10 +324,14 @@ readfile(const char *path)
    if (fd < 0)
        return NULL;
    if (fstat(fd, &statbuf) < 0)
+   {
+       close(fd);
        return NULL;
+   }
    if (statbuf.st_size == 0)
    {
        /* empty file */
+       close(fd);
        result = (char **) pg_malloc(sizeof(char *));
        *result = NULL;
        return result;
@@ -343,14 +347,17 @@ readfile(const char *path)
        return NULL;
    }
 
-   /* count newlines */
+   /*
+    * Count newlines. We expect there to be a newline after each full line,
+    * including one at the end of file. If there isn't a newline at the end,
+    * any characters after the last newline will be ignored.
+    */
    nlines = 0;
-   for (i = 0; i < len - 1; i++)
+   for (i = 0; i < len; i++)
    {
        if (buffer[i] == '\n')
            nlines++;
    }
-   nlines++; /* account for the last line */
 
    /* set up the result buffer */
    result = (char **) pg_malloc((nlines + 1) * sizeof(char *));
@@ -360,7 +367,7 @@ readfile(const char *path)
    n = 0;
    for (i = 0; i < len; i++)
    {
-       if (buffer[i] == '\n' || i == len - 1)
+       if (buffer[i] == '\n')
        {
            int     slen = &buffer[i] - linebegin + 1;
            char   *linebuf = pg_malloc(slen + 1);