LCOV - code coverage report
Current view: top level - src/bin/pg_upgrade - util.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 68 83 81.9 %
Date: 2019-11-13 22:07:24 Functions: 10 11 90.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  *  util.c
       3             :  *
       4             :  *  utility functions
       5             :  *
       6             :  *  Copyright (c) 2010-2019, PostgreSQL Global Development Group
       7             :  *  src/bin/pg_upgrade/util.c
       8             :  */
       9             : 
      10             : #include "postgres_fe.h"
      11             : 
      12             : #include <signal.h>
      13             : 
      14             : #include "common/username.h"
      15             : #include "pg_upgrade.h"
      16             : 
      17             : LogOpts     log_opts;
      18             : 
      19             : static void pg_log_v(eLogType type, const char *fmt, va_list ap) pg_attribute_printf(2, 0);
      20             : 
      21             : 
      22             : /*
      23             :  * report_status()
      24             :  *
      25             :  *  Displays the result of an operation (ok, failed, error message,...)
      26             :  */
      27             : void
      28          60 : report_status(eLogType type, const char *fmt,...)
      29             : {
      30             :     va_list     args;
      31             :     char        message[MAX_STRING];
      32             : 
      33          60 :     va_start(args, fmt);
      34          60 :     vsnprintf(message, sizeof(message), fmt, args);
      35          60 :     va_end(args);
      36             : 
      37          60 :     pg_log(type, "%s\n", message);
      38          60 : }
      39             : 
      40             : 
      41             : /* force blank output for progress display */
      42             : void
      43           6 : end_progress_output(void)
      44             : {
      45             :     /*
      46             :      * In case nothing printed; pass a space so gcc doesn't complain about
      47             :      * empty format string.
      48             :      */
      49           6 :     prep_status(" ");
      50           6 : }
      51             : 
      52             : 
      53             : /*
      54             :  * prep_status
      55             :  *
      56             :  *  Displays a message that describes an operation we are about to begin.
      57             :  *  We pad the message out to MESSAGE_WIDTH characters so that all of the "ok" and
      58             :  *  "failed" indicators line up nicely.
      59             :  *
      60             :  *  A typical sequence would look like this:
      61             :  *      prep_status("about to flarb the next %d files", fileCount );
      62             :  *
      63             :  *      if(( message = flarbFiles(fileCount)) == NULL)
      64             :  *        report_status(PG_REPORT, "ok" );
      65             :  *      else
      66             :  *        pg_log(PG_FATAL, "failed - %s\n", message );
      67             :  */
      68             : void
      69          64 : prep_status(const char *fmt,...)
      70             : {
      71             :     va_list     args;
      72             :     char        message[MAX_STRING];
      73             : 
      74          64 :     va_start(args, fmt);
      75          64 :     vsnprintf(message, sizeof(message), fmt, args);
      76          64 :     va_end(args);
      77             : 
      78          64 :     if (strlen(message) > 0 && message[strlen(message) - 1] == '\n')
      79           4 :         pg_log(PG_REPORT, "%s", message);
      80             :     else
      81             :         /* trim strings that don't end in a newline */
      82          60 :         pg_log(PG_REPORT, "%-*s", MESSAGE_WIDTH, message);
      83          64 : }
      84             : 
      85             : 
      86             : static void
      87        5956 : pg_log_v(eLogType type, const char *fmt, va_list ap)
      88             : {
      89             :     char        message[QUERY_ALLOC];
      90             : 
      91        5956 :     vsnprintf(message, sizeof(message), _(fmt), ap);
      92             : 
      93             :     /* PG_VERBOSE and PG_STATUS are only output in verbose mode */
      94             :     /* fopen() on log_opts.internal might have failed, so check it */
      95        6094 :     if (((type != PG_VERBOSE && type != PG_STATUS) || log_opts.verbose) &&
      96         138 :         log_opts.internal != NULL)
      97             :     {
      98         138 :         if (type == PG_STATUS)
      99             :             /* status messages need two leading spaces and a newline */
     100           0 :             fprintf(log_opts.internal, "  %s\n", message);
     101             :         else
     102         138 :             fprintf(log_opts.internal, "%s", message);
     103         138 :         fflush(log_opts.internal);
     104             :     }
     105             : 
     106        5956 :     switch (type)
     107             :     {
     108             :         case PG_VERBOSE:
     109        3094 :             if (log_opts.verbose)
     110           0 :                 printf("%s", message);
     111        3094 :             break;
     112             : 
     113             :         case PG_STATUS:
     114             :             /* for output to a display, do leading truncation and append \r */
     115        2724 :             if (isatty(fileno(stdout)))
     116             :                 /* -2 because we use a 2-space indent */
     117           0 :                 printf("  %s%-*.*s\r",
     118             :                 /* prefix with "..." if we do leading truncation */
     119             :                        strlen(message) <= MESSAGE_WIDTH - 2 ? "" : "...",
     120             :                        MESSAGE_WIDTH - 2, MESSAGE_WIDTH - 2,
     121             :                 /* optional leading truncation */
     122             :                        strlen(message) <= MESSAGE_WIDTH - 2 ? message :
     123             :                        message + strlen(message) - MESSAGE_WIDTH + 3 + 2);
     124             :             else
     125        2724 :                 printf("  %s\n", message);
     126        2724 :             break;
     127             : 
     128             :         case PG_REPORT:
     129             :         case PG_WARNING:
     130         138 :             printf("%s", message);
     131         138 :             break;
     132             : 
     133             :         case PG_FATAL:
     134           0 :             printf("\n%s", message);
     135           0 :             printf(_("Failure, exiting\n"));
     136           0 :             exit(1);
     137             :             break;
     138             : 
     139             :         default:
     140           0 :             break;
     141             :     }
     142        5956 :     fflush(stdout);
     143        5956 : }
     144             : 
     145             : 
     146             : void
     147        5956 : pg_log(eLogType type, const char *fmt,...)
     148             : {
     149             :     va_list     args;
     150             : 
     151        5956 :     va_start(args, fmt);
     152        5956 :     pg_log_v(type, fmt, args);
     153        5956 :     va_end(args);
     154        5956 : }
     155             : 
     156             : 
     157             : void
     158           0 : pg_fatal(const char *fmt,...)
     159             : {
     160             :     va_list     args;
     161             : 
     162           0 :     va_start(args, fmt);
     163           0 :     pg_log_v(PG_FATAL, fmt, args);
     164           0 :     va_end(args);
     165           0 :     printf(_("Failure, exiting\n"));
     166           0 :     exit(1);
     167             : }
     168             : 
     169             : 
     170             : void
     171          60 : check_ok(void)
     172             : {
     173             :     /* all seems well */
     174          60 :     report_status(PG_REPORT, "ok");
     175          60 :     fflush(stdout);
     176          60 : }
     177             : 
     178             : 
     179             : /*
     180             :  * quote_identifier()
     181             :  *      Properly double-quote a SQL identifier.
     182             :  *
     183             :  * The result should be pg_free'd, but most callers don't bother because
     184             :  * memory leakage is not a big deal in this program.
     185             :  */
     186             : char *
     187           4 : quote_identifier(const char *s)
     188             : {
     189           4 :     char       *result = pg_malloc(strlen(s) * 2 + 3);
     190           4 :     char       *r = result;
     191             : 
     192           4 :     *r++ = '"';
     193          44 :     while (*s)
     194             :     {
     195          36 :         if (*s == '"')
     196           0 :             *r++ = *s;
     197          36 :         *r++ = *s;
     198          36 :         s++;
     199             :     }
     200           4 :     *r++ = '"';
     201           4 :     *r++ = '\0';
     202             : 
     203           4 :     return result;
     204             : }
     205             : 
     206             : 
     207             : /*
     208             :  * get_user_info()
     209             :  */
     210             : int
     211           2 : get_user_info(char **user_name_p)
     212             : {
     213             :     int         user_id;
     214             :     const char *user_name;
     215             :     char       *errstr;
     216             : 
     217             : #ifndef WIN32
     218           2 :     user_id = geteuid();
     219             : #else
     220             :     user_id = 1;
     221             : #endif
     222             : 
     223           2 :     user_name = get_user_name(&errstr);
     224           2 :     if (!user_name)
     225           0 :         pg_fatal("%s\n", errstr);
     226             : 
     227             :     /* make a copy */
     228           2 :     *user_name_p = pg_strdup(user_name);
     229             : 
     230           2 :     return user_id;
     231             : }
     232             : 
     233             : 
     234             : /*
     235             :  *  str2uint()
     236             :  *
     237             :  *  convert string to oid
     238             :  */
     239             : unsigned int
     240          76 : str2uint(const char *str)
     241             : {
     242          76 :     return strtoul(str, NULL, 10);
     243             : }
     244             : 
     245             : 
     246             : /*
     247             :  *  pg_putenv()
     248             :  *
     249             :  *  This is like putenv(), but takes two arguments.
     250             :  *  It also does unsetenv() if val is NULL.
     251             :  */
     252             : void
     253          74 : pg_putenv(const char *var, const char *val)
     254             : {
     255          74 :     if (val)
     256             :     {
     257             : #ifndef WIN32
     258             :         char       *envstr;
     259             : 
     260          10 :         envstr = psprintf("%s=%s", var, val);
     261          10 :         putenv(envstr);
     262             : 
     263             :         /*
     264             :          * Do not free envstr because it becomes part of the environment on
     265             :          * some operating systems.  See port/unsetenv.c::unsetenv.
     266             :          */
     267             : #else
     268             :         SetEnvironmentVariableA(var, val);
     269             : #endif
     270             :     }
     271             :     else
     272             :     {
     273             : #ifndef WIN32
     274          64 :         unsetenv(var);
     275             : #else
     276             :         SetEnvironmentVariableA(var, "");
     277             : #endif
     278             :     }
     279          74 : }

Generated by: LCOV version 1.13