Teach libpq to handle arbitrary-length lines in .pgpass files.

Historically there's been a hard-wired assumption here that no line of
a .pgpass file could be as long as NAMEDATALEN*5 bytes.  That's a bit
shaky to start off with, because (a) there's no reason to suppose that
host names fit in NAMEDATALEN, and (b) this figure fails to allow for
backslash escape characters.  However, it fails completely if someone
wants to use a very long password, and we're now hearing reports of
people wanting to use "security tokens" that can run up to several
hundred bytes.  Another angle is that the file is specified to allow
comment lines, but there's no reason to assume that long comment lines
aren't possible.

Rather than guessing at what might be a more suitable limit, let's
replace the fixed-size buffer with an expansible PQExpBuffer.  That
adds one malloc/free cycle to the typical use-case, but that's surely
pretty cheap relative to the I/O this code has to do.

Also, add TAP test cases to exercise this code, because there was no
test coverage before.

This reverts most of commit 2eb3bc588, as there's no longer a need for
a warning message about overlength .pgpass lines.  (I kept the explicit
check for comment lines, though.)

In HEAD and v13, this also fixes an oversight in 74a308cf5: there's not
much point in explicit_bzero'ing the line buffer if we only do so in two
of the three exit paths.

Back-patch to all supported branches, except that the test case only
goes back to v10 where src/test/authentication/ was added.

Discussion: https://postgr.es/m/4187382.1598909041@sss.pgh.pa.us

diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c
index 52f8ec9d6300faabdcba97b7430f01c9544f15b4..894162efd84e162f72ccddac5ab7cd376bd5a76a 100644 (file)
--- a/src/interfaces/libpq/fe-connect.c
+++ b/src/interfaces/libpq/fe-connect.c
@@ -5825,9 +5825,7 @@ PasswordFromFile(char *hostname, char *port, char *dbname, char *username)
    FILE       *fp;
    char        pgpassfile[MAXPGPATH];
    struct stat stat_buf;
-
-#define LINELEN NAMEDATALEN*5
-   char        buf[LINELEN];
+   PQExpBufferData buf;
 
    if (dbname == NULL || strlen(dbname) == 0)
        return NULL;
@@ -5886,63 +5884,81 @@ PasswordFromFile(char *hostname, char *port, char *dbname, char *username)
    if (fp == NULL)
        return NULL;
 
+   /* Use an expansible buffer to accommodate any reasonable line length */
+   initPQExpBuffer(&buf);
+
    while (!feof(fp) && !ferror(fp))
    {
-       char       *t = buf,
-                  *ret,
-                  *p1,
-                  *p2;
-       int         len;
+       /* Make sure there's a reasonable amount of room in the buffer */
+       if (!enlargePQExpBuffer(&buf, 128))
+           break;
 
-       if (fgets(buf, sizeof(buf), fp) == NULL)
+       /* Read some data, appending it to what we already have */
+       if (fgets(buf.data + buf.len, buf.maxlen - buf.len, fp) == NULL)
            break;
+       buf.len += strlen(buf.data + buf.len);
 
-       len = strlen(buf);
+       /* If we don't yet have a whole line, loop around to read more */
+       if (!(buf.len > 0 && buf.data[buf.len - 1] == '\n') && !feof(fp))
+           continue;
 
-       /* Remove trailing newline */
-       if (len > 0 && buf[len - 1] == '\n')
+       /* ignore comments */
+       if (buf.data[0] != '#')
        {
-           buf[--len] = '\0';
-           /* Handle DOS-style line endings, too, even when not on Windows */
-           if (len > 0 && buf[len - 1] == '\r')
-               buf[--len] = '\0';
-       }
+           char       *t = buf.data;
+           int         len = buf.len;
 
-       if (len == 0)
-           continue;
+           /* Remove trailing newline */
+           if (len > 0 && t[len - 1] == '\n')
+           {
+               t[--len] = '\0';
+               /* Handle DOS-style line endings, too */
+               if (len > 0 && t[len - 1] == '\r')
+                   t[--len] = '\0';
+           }
 
-       if ((t = pwdfMatchesString(t, hostname)) == NULL ||
-           (t = pwdfMatchesString(t, port)) == NULL ||
-           (t = pwdfMatchesString(t, dbname)) == NULL ||
-           (t = pwdfMatchesString(t, username)) == NULL)
-           continue;
+           if (len > 0 &&
+               (t = pwdfMatchesString(t, hostname)) != NULL &&
+               (t = pwdfMatchesString(t, port)) != NULL &&
+               (t = pwdfMatchesString(t, dbname)) != NULL &&
+               (t = pwdfMatchesString(t, username)) != NULL)
+           {
+               /* Found a match. */
+               char       *ret,
+                          *p1,
+                          *p2;
 
-       /* Found a match. */
-       ret = strdup(t);
-       fclose(fp);
+               ret = strdup(t);
 
-       if (!ret)
-       {
-           /* Out of memory. XXX: an error message would be nice. */
-           return NULL;
-       }
+               fclose(fp);
+               termPQExpBuffer(&buf);
 
-       /* De-escape password. */
-       for (p1 = p2 = ret; *p1 != ':' && *p1 != '\0'; ++p1, ++p2)
-       {
-           if (*p1 == '\\' && p1[1] != '\0')
-               ++p1;
-           *p2 = *p1;
+               if (!ret)
+               {
+                   /* Out of memory. XXX: an error message would be nice. */
+                   return NULL;
+               }
+
+               /* De-escape password. */
+               for (p1 = p2 = ret; *p1 != ':' && *p1 != '\0'; ++p1, ++p2)
+               {
+                   if (*p1 == '\\' && p1[1] != '\0')
+                       ++p1;
+                   *p2 = *p1;
+               }
+               *p2 = '\0';
+
+               return ret;
+           }
        }
-       *p2 = '\0';
 
-       return ret;
+       /* No match, reset buffer to prepare for next line. */
+       buf.len = 0;
    }
 
    fclose(fp);
+   termPQExpBuffer(&buf);
    return NULL;
-
-#undef LINELEN
 }