LCOV - code coverage report
Current view: top level - src/bin/psql - prompt.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 0 131 0.0 %
Date: 2019-09-19 16:06:56 Functions: 0 1 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * psql - the PostgreSQL interactive terminal
       3             :  *
       4             :  * Copyright (c) 2000-2019, PostgreSQL Global Development Group
       5             :  *
       6             :  * src/bin/psql/prompt.c
       7             :  */
       8             : #include "postgres_fe.h"
       9             : 
      10             : #ifdef WIN32
      11             : #include <io.h>
      12             : #include <win32.h>
      13             : #endif
      14             : 
      15             : #ifdef HAVE_UNIX_SOCKETS
      16             : #include <unistd.h>
      17             : #include <netdb.h>
      18             : #endif
      19             : 
      20             : #include "common.h"
      21             : #include "input.h"
      22             : #include "prompt.h"
      23             : #include "settings.h"
      24             : 
      25             : #include "common/string.h"
      26             : 
      27             : /*--------------------------
      28             :  * get_prompt
      29             :  *
      30             :  * Returns a statically allocated prompt made by interpolating certain
      31             :  * tcsh style escape sequences into pset.vars "PROMPT1|2|3".
      32             :  * (might not be completely multibyte safe)
      33             :  *
      34             :  * Defined interpolations are:
      35             :  * %M - database server "hostname.domainname", "[local]" for AF_UNIX
      36             :  *      sockets, "[local:/dir/name]" if not default
      37             :  * %m - like %M, but hostname only (before first dot), or always "[local]"
      38             :  * %p - backend pid
      39             :  * %> - database server port number
      40             :  * %n - database user name
      41             :  * %/ - current database
      42             :  * %~ - like %/ but "~" when database name equals user name
      43             :  * %# - "#" if superuser, ">" otherwise
      44             :  * %R - in prompt1 normally =, or ^ if single line mode,
      45             :  *          or a ! if session is not connected to a database;
      46             :  *      in prompt2 -, *, ', or ";
      47             :  *      in prompt3 nothing
      48             :  * %x - transaction status: empty, *, !, ? (unknown or no connection)
      49             :  * %l - The line number inside the current statement, starting from 1.
      50             :  * %? - the error code of the last query (not yet implemented)
      51             :  * %% - a percent sign
      52             :  *
      53             :  * %[0-9]          - the character with the given decimal code
      54             :  * %0[0-7]         - the character with the given octal code
      55             :  * %0x[0-9A-Fa-f]  - the character with the given hexadecimal code
      56             :  *
      57             :  * %`command`      - The result of executing command in /bin/sh with trailing
      58             :  *                   newline stripped.
      59             :  * %:name:         - The value of the psql variable 'name'
      60             :  * (those will not be rescanned for more escape sequences!)
      61             :  *
      62             :  * %[ ... %]       - tell readline that the contained text is invisible
      63             :  *
      64             :  * If the application-wide prompts become NULL somehow, the returned string
      65             :  * will be empty (not NULL!).
      66             :  *--------------------------
      67             :  */
      68             : 
      69             : char *
      70           0 : get_prompt(promptStatus_t status, ConditionalStack cstack)
      71             : {
      72             : #define MAX_PROMPT_SIZE 256
      73             :     static char destination[MAX_PROMPT_SIZE + 1];
      74             :     char        buf[MAX_PROMPT_SIZE + 1];
      75           0 :     bool        esc = false;
      76             :     const char *p;
      77           0 :     const char *prompt_string = "? ";
      78             : 
      79           0 :     switch (status)
      80             :     {
      81             :         case PROMPT_READY:
      82           0 :             prompt_string = pset.prompt1;
      83           0 :             break;
      84             : 
      85             :         case PROMPT_CONTINUE:
      86             :         case PROMPT_SINGLEQUOTE:
      87             :         case PROMPT_DOUBLEQUOTE:
      88             :         case PROMPT_DOLLARQUOTE:
      89             :         case PROMPT_COMMENT:
      90             :         case PROMPT_PAREN:
      91           0 :             prompt_string = pset.prompt2;
      92           0 :             break;
      93             : 
      94             :         case PROMPT_COPY:
      95           0 :             prompt_string = pset.prompt3;
      96           0 :             break;
      97             :     }
      98             : 
      99           0 :     destination[0] = '\0';
     100             : 
     101           0 :     for (p = prompt_string;
     102           0 :          *p && strlen(destination) < sizeof(destination) - 1;
     103           0 :          p++)
     104             :     {
     105           0 :         memset(buf, 0, sizeof(buf));
     106           0 :         if (esc)
     107             :         {
     108           0 :             switch (*p)
     109             :             {
     110             :                     /* Current database */
     111             :                 case '/':
     112           0 :                     if (pset.db)
     113           0 :                         strlcpy(buf, PQdb(pset.db), sizeof(buf));
     114           0 :                     break;
     115             :                 case '~':
     116           0 :                     if (pset.db)
     117             :                     {
     118             :                         const char *var;
     119             : 
     120           0 :                         if (strcmp(PQdb(pset.db), PQuser(pset.db)) == 0 ||
     121           0 :                             ((var = getenv("PGDATABASE")) && strcmp(var, PQdb(pset.db)) == 0))
     122           0 :                             strlcpy(buf, "~", sizeof(buf));
     123             :                         else
     124           0 :                             strlcpy(buf, PQdb(pset.db), sizeof(buf));
     125             :                     }
     126           0 :                     break;
     127             : 
     128             :                     /* DB server hostname (long/short) */
     129             :                 case 'M':
     130             :                 case 'm':
     131           0 :                     if (pset.db)
     132             :                     {
     133           0 :                         const char *host = PQhost(pset.db);
     134             : 
     135             :                         /* INET socket */
     136           0 :                         if (host && host[0] && !is_absolute_path(host))
     137             :                         {
     138           0 :                             strlcpy(buf, host, sizeof(buf));
     139           0 :                             if (*p == 'm')
     140           0 :                                 buf[strcspn(buf, ".")] = '\0';
     141             :                         }
     142             : #ifdef HAVE_UNIX_SOCKETS
     143             :                         /* UNIX socket */
     144             :                         else
     145             :                         {
     146           0 :                             if (!host
     147           0 :                                 || strcmp(host, DEFAULT_PGSOCKET_DIR) == 0
     148           0 :                                 || *p == 'm')
     149           0 :                                 strlcpy(buf, "[local]", sizeof(buf));
     150             :                             else
     151           0 :                                 snprintf(buf, sizeof(buf), "[local:%s]", host);
     152             :                         }
     153             : #endif
     154             :                     }
     155           0 :                     break;
     156             :                     /* DB server port number */
     157             :                 case '>':
     158           0 :                     if (pset.db && PQport(pset.db))
     159           0 :                         strlcpy(buf, PQport(pset.db), sizeof(buf));
     160           0 :                     break;
     161             :                     /* DB server user name */
     162             :                 case 'n':
     163           0 :                     if (pset.db)
     164           0 :                         strlcpy(buf, session_username(), sizeof(buf));
     165           0 :                     break;
     166             :                     /* backend pid */
     167             :                 case 'p':
     168           0 :                     if (pset.db)
     169             :                     {
     170           0 :                         int         pid = PQbackendPID(pset.db);
     171             : 
     172           0 :                         if (pid)
     173           0 :                             snprintf(buf, sizeof(buf), "%d", pid);
     174             :                     }
     175           0 :                     break;
     176             : 
     177             :                 case '0':
     178             :                 case '1':
     179             :                 case '2':
     180             :                 case '3':
     181             :                 case '4':
     182             :                 case '5':
     183             :                 case '6':
     184             :                 case '7':
     185           0 :                     *buf = (char) strtol(p, unconstify(char **, &p), 8);
     186           0 :                     --p;
     187           0 :                     break;
     188             :                 case 'R':
     189           0 :                     switch (status)
     190             :                     {
     191             :                         case PROMPT_READY:
     192           0 :                             if (cstack != NULL && !conditional_active(cstack))
     193           0 :                                 buf[0] = '@';
     194           0 :                             else if (!pset.db)
     195           0 :                                 buf[0] = '!';
     196           0 :                             else if (!pset.singleline)
     197           0 :                                 buf[0] = '=';
     198             :                             else
     199           0 :                                 buf[0] = '^';
     200           0 :                             break;
     201             :                         case PROMPT_CONTINUE:
     202           0 :                             buf[0] = '-';
     203           0 :                             break;
     204             :                         case PROMPT_SINGLEQUOTE:
     205           0 :                             buf[0] = '\'';
     206           0 :                             break;
     207             :                         case PROMPT_DOUBLEQUOTE:
     208           0 :                             buf[0] = '"';
     209           0 :                             break;
     210             :                         case PROMPT_DOLLARQUOTE:
     211           0 :                             buf[0] = '$';
     212           0 :                             break;
     213             :                         case PROMPT_COMMENT:
     214           0 :                             buf[0] = '*';
     215           0 :                             break;
     216             :                         case PROMPT_PAREN:
     217           0 :                             buf[0] = '(';
     218           0 :                             break;
     219             :                         default:
     220           0 :                             buf[0] = '\0';
     221           0 :                             break;
     222             :                     }
     223           0 :                     break;
     224             : 
     225             :                 case 'x':
     226           0 :                     if (!pset.db)
     227           0 :                         buf[0] = '?';
     228             :                     else
     229           0 :                         switch (PQtransactionStatus(pset.db))
     230             :                         {
     231             :                             case PQTRANS_IDLE:
     232           0 :                                 buf[0] = '\0';
     233           0 :                                 break;
     234             :                             case PQTRANS_ACTIVE:
     235             :                             case PQTRANS_INTRANS:
     236           0 :                                 buf[0] = '*';
     237           0 :                                 break;
     238             :                             case PQTRANS_INERROR:
     239           0 :                                 buf[0] = '!';
     240           0 :                                 break;
     241             :                             default:
     242           0 :                                 buf[0] = '?';
     243           0 :                                 break;
     244             :                         }
     245           0 :                     break;
     246             : 
     247             :                 case 'l':
     248           0 :                     snprintf(buf, sizeof(buf), UINT64_FORMAT, pset.stmt_lineno);
     249           0 :                     break;
     250             : 
     251             :                 case '?':
     252             :                     /* not here yet */
     253           0 :                     break;
     254             : 
     255             :                 case '#':
     256           0 :                     if (is_superuser())
     257           0 :                         buf[0] = '#';
     258             :                     else
     259           0 :                         buf[0] = '>';
     260           0 :                     break;
     261             : 
     262             :                     /* execute command */
     263             :                 case '`':
     264             :                     {
     265             :                         FILE       *fd;
     266           0 :                         char       *file = pg_strdup(p + 1);
     267             :                         int         cmdend;
     268             : 
     269           0 :                         cmdend = strcspn(file, "`");
     270           0 :                         file[cmdend] = '\0';
     271           0 :                         fd = popen(file, "r");
     272           0 :                         if (fd)
     273             :                         {
     274           0 :                             if (fgets(buf, sizeof(buf), fd) == NULL)
     275           0 :                                 buf[0] = '\0';
     276           0 :                             pclose(fd);
     277             :                         }
     278             : 
     279             :                         /* strip trailing newline and carriage return */
     280           0 :                         (void) pg_strip_crlf(buf);
     281             : 
     282           0 :                         free(file);
     283           0 :                         p += cmdend + 1;
     284           0 :                         break;
     285             :                     }
     286             : 
     287             :                     /* interpolate variable */
     288             :                 case ':':
     289             :                     {
     290             :                         char       *name;
     291             :                         const char *val;
     292             :                         int         nameend;
     293             : 
     294           0 :                         name = pg_strdup(p + 1);
     295           0 :                         nameend = strcspn(name, ":");
     296           0 :                         name[nameend] = '\0';
     297           0 :                         val = GetVariable(pset.vars, name);
     298           0 :                         if (val)
     299           0 :                             strlcpy(buf, val, sizeof(buf));
     300           0 :                         free(name);
     301           0 :                         p += nameend + 1;
     302           0 :                         break;
     303             :                     }
     304             : 
     305             :                 case '[':
     306             :                 case ']':
     307             : #if defined(USE_READLINE) && defined(RL_PROMPT_START_IGNORE)
     308             : 
     309             :                     /*
     310             :                      * readline >=4.0 undocumented feature: non-printing
     311             :                      * characters in prompt strings must be marked as such, in
     312             :                      * order to properly display the line during editing.
     313             :                      */
     314           0 :                     buf[0] = (*p == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
     315           0 :                     buf[1] = '\0';
     316             : #endif                          /* USE_READLINE */
     317           0 :                     break;
     318             : 
     319             :                 default:
     320           0 :                     buf[0] = *p;
     321           0 :                     buf[1] = '\0';
     322           0 :                     break;
     323             : 
     324             :             }
     325           0 :             esc = false;
     326             :         }
     327           0 :         else if (*p == '%')
     328           0 :             esc = true;
     329             :         else
     330             :         {
     331           0 :             buf[0] = *p;
     332           0 :             buf[1] = '\0';
     333           0 :             esc = false;
     334             :         }
     335             : 
     336           0 :         if (!esc)
     337           0 :             strlcat(destination, buf, sizeof(destination));
     338             :     }
     339             : 
     340           0 :     return destination;
     341             : }

Generated by: LCOV version 1.13