PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
variable.c File Reference
#include "postgres.h"
#include <ctype.h>
#include "access/htup_details.h"
#include "access/parallel.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xlogprefetcher.h"
#include "catalog/pg_authid.h"
#include "common/string.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "postmaster/postmaster.h"
#include "postmaster/syslogger.h"
#include "storage/bufmgr.h"
#include "utils/acl.h"
#include "utils/backend_status.h"
#include "utils/datetime.h"
#include "utils/fmgrprotos.h"
#include "utils/guc_hooks.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/timestamp.h"
#include "utils/tzparser.h"
#include "utils/varlena.h"
Include dependency graph for variable.c:

Go to the source code of this file.

Data Structures

struct  role_auth_extra
 

Functions

bool check_datestyle (char **newval, void **extra, GucSource source)
 
void assign_datestyle (const char *newval, void *extra)
 
bool check_timezone (char **newval, void **extra, GucSource source)
 
void assign_timezone (const char *newval, void *extra)
 
const char * show_timezone (void)
 
bool check_log_timezone (char **newval, void **extra, GucSource source)
 
void assign_log_timezone (const char *newval, void *extra)
 
const char * show_log_timezone (void)
 
bool check_timezone_abbreviations (char **newval, void **extra, GucSource source)
 
void assign_timezone_abbreviations (const char *newval, void *extra)
 
bool check_transaction_read_only (bool *newval, void **extra, GucSource source)
 
bool check_transaction_isolation (int *newval, void **extra, GucSource source)
 
bool check_transaction_deferrable (bool *newval, void **extra, GucSource source)
 
bool check_random_seed (double *newval, void **extra, GucSource source)
 
void assign_random_seed (double newval, void *extra)
 
const char * show_random_seed (void)
 
bool check_client_encoding (char **newval, void **extra, GucSource source)
 
void assign_client_encoding (const char *newval, void *extra)
 
bool check_session_authorization (char **newval, void **extra, GucSource source)
 
void assign_session_authorization (const char *newval, void *extra)
 
bool check_role (char **newval, void **extra, GucSource source)
 
void assign_role (const char *newval, void *extra)
 
const char * show_role (void)
 
bool check_canonical_path (char **newval, void **extra, GucSource source)
 
bool check_application_name (char **newval, void **extra, GucSource source)
 
void assign_application_name (const char *newval, void *extra)
 
bool check_cluster_name (char **newval, void **extra, GucSource source)
 
void assign_maintenance_io_concurrency (int newval, void *extra)
 
const char * show_data_directory_mode (void)
 
const char * show_log_file_mode (void)
 
const char * show_unix_socket_permissions (void)
 
bool check_bonjour (bool *newval, void **extra, GucSource source)
 
bool check_default_with_oids (bool *newval, void **extra, GucSource source)
 
bool check_effective_io_concurrency (int *newval, void **extra, GucSource source)
 
bool check_maintenance_io_concurrency (int *newval, void **extra, GucSource source)
 
bool check_ssl (bool *newval, void **extra, GucSource source)
 

Function Documentation

◆ assign_application_name()

void assign_application_name ( const char *  newval,
void *  extra 
)

Definition at line 1108 of file variable.c.

1109{
1110 /* Update the pg_stat_activity view */
1112}
void pgstat_report_appname(const char *appname)
#define newval

References newval, and pgstat_report_appname().

◆ assign_client_encoding()

void assign_client_encoding ( const char *  newval,
void *  extra 
)

Definition at line 786 of file variable.c.

787{
788 int encoding = *((int *) extra);
789
790 /*
791 * In a parallel worker, we never override the client encoding that was
792 * set by ParallelWorkerMain().
793 */
794 if (IsParallelWorker())
795 return;
796
797 /* We do not expect an error if PrepareClientEncoding succeeded */
799 elog(LOG, "SetClientEncoding(%d) failed", encoding);
800}
#define LOG
Definition: elog.h:31
#define elog(elevel,...)
Definition: elog.h:225
#define IsParallelWorker()
Definition: parallel.h:60
int SetClientEncoding(int encoding)
Definition: mbutils.c:208
int32 encoding
Definition: pg_database.h:41

References elog, encoding, IsParallelWorker, LOG, and SetClientEncoding().

◆ assign_datestyle()

void assign_datestyle ( const char *  newval,
void *  extra 
)

Definition at line 244 of file variable.c.

245{
246 int *myextra = (int *) extra;
247
248 DateStyle = myextra[0];
249 DateOrder = myextra[1];
250}
int DateStyle
Definition: globals.c:124
int DateOrder
Definition: globals.c:125

References DateOrder, and DateStyle.

◆ assign_log_timezone()

void assign_log_timezone ( const char *  newval,
void *  extra 
)

Definition at line 456 of file variable.c.

457{
458 log_timezone = *((pg_tz **) extra);
459}
PGDLLIMPORT pg_tz * log_timezone
Definition: pgtz.c:31
Definition: pgtz.h:66

References log_timezone.

◆ assign_maintenance_io_concurrency()

void assign_maintenance_io_concurrency ( int  newval,
void *  extra 
)

Definition at line 1146 of file variable.c.

1147{
1148#ifdef USE_PREFETCH
1149 /*
1150 * Reconfigure recovery prefetching, because a setting it depends on
1151 * changed.
1152 */
1154 if (AmStartupProcess())
1156#endif
1157}
int maintenance_io_concurrency
Definition: bufmgr.c:158
#define AmStartupProcess()
Definition: miscadmin.h:388
void XLogPrefetchReconfigure(void)

References AmStartupProcess, maintenance_io_concurrency, newval, and XLogPrefetchReconfigure().

◆ assign_random_seed()

void assign_random_seed ( double  newval,
void *  extra 
)

Definition at line 668 of file variable.c.

669{
670 /* We'll do this at most once for any setting of the GUC variable */
671 if (*((int *) extra))
673 *((int *) extra) = 0;
674}
Datum Float8GetDatum(float8 X)
Definition: fmgr.c:1816
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:641
Datum setseed(PG_FUNCTION_ARGS)

References DirectFunctionCall1, Float8GetDatum(), newval, and setseed().

◆ assign_role()

void assign_role ( const char *  newval,
void *  extra 
)

Definition at line 1026 of file variable.c.

1027{
1028 role_auth_extra *myextra = (role_auth_extra *) extra;
1029
1030 SetCurrentRoleId(myextra->roleid, myextra->is_superuser);
1031}
void SetCurrentRoleId(Oid roleid, bool is_superuser)
Definition: miscinit.c:1004
bool is_superuser
Definition: variable.c:811

References role_auth_extra::is_superuser, role_auth_extra::roleid, and SetCurrentRoleId().

◆ assign_session_authorization()

void assign_session_authorization ( const char *  newval,
void *  extra 
)

Definition at line 912 of file variable.c.

913{
914 role_auth_extra *myextra = (role_auth_extra *) extra;
915
916 /* Do nothing for the boot_val default of NULL */
917 if (!myextra)
918 return;
919
920 SetSessionAuthorization(myextra->roleid, myextra->is_superuser);
921}
void SetSessionAuthorization(Oid userid, bool is_superuser)
Definition: miscinit.c:968

References role_auth_extra::is_superuser, role_auth_extra::roleid, and SetSessionAuthorization().

◆ assign_timezone()

void assign_timezone ( const char *  newval,
void *  extra 
)

Definition at line 381 of file variable.c.

382{
383 session_timezone = *((pg_tz **) extra);
384 /* datetime.c's cache of timezone abbrevs may now be obsolete */
386}
void ClearTimeZoneAbbrevCache(void)
Definition: datetime.c:3221
PGDLLIMPORT pg_tz * session_timezone
Definition: pgtz.c:28

References ClearTimeZoneAbbrevCache(), and session_timezone.

◆ assign_timezone_abbreviations()

void assign_timezone_abbreviations ( const char *  newval,
void *  extra 
)

Definition at line 519 of file variable.c.

520{
521 /* Do nothing for the boot_val default of NULL */
522 if (!extra)
523 return;
524
526}
void InstallTimeZoneAbbrevs(TimeZoneAbbrevTable *tbl)
Definition: datetime.c:5073

References InstallTimeZoneAbbrevs().

◆ check_application_name()

bool check_application_name ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1080 of file variable.c.

1081{
1082 char *clean;
1083 char *ret;
1084
1085 /* Only allow clean ASCII chars in the application name */
1087 if (!clean)
1088 return false;
1089
1090 ret = guc_strdup(WARNING, clean);
1091 if (!ret)
1092 {
1093 pfree(clean);
1094 return false;
1095 }
1096
1097 guc_free(*newval);
1098
1099 pfree(clean);
1100 *newval = ret;
1101 return true;
1102}
#define WARNING
Definition: elog.h:36
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:29
void guc_free(void *ptr)
Definition: guc.c:689
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:677
void pfree(void *pointer)
Definition: mcxt.c:1521
char * pg_clean_ascii(const char *str, int alloc_flags)
Definition: string.c:85

References guc_free(), guc_strdup(), MCXT_ALLOC_NO_OOM, newval, pfree(), pg_clean_ascii(), and WARNING.

◆ check_bonjour()

bool check_bonjour ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1207 of file variable.c.

1208{
1209#ifndef USE_BONJOUR
1210 if (*newval)
1211 {
1212 GUC_check_errmsg("Bonjour is not supported by this build");
1213 return false;
1214 }
1215#endif
1216 return true;
1217}
#define GUC_check_errmsg
Definition: guc.h:472

References GUC_check_errmsg, and newval.

◆ check_canonical_path()

bool check_canonical_path ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1059 of file variable.c.

1060{
1061 /*
1062 * Since canonicalize_path never enlarges the string, we can just modify
1063 * newval in-place. But watch out for NULL, which is the default value
1064 * for external_pid_file.
1065 */
1066 if (*newval)
1068 return true;
1069}
void canonicalize_path(char *path)
Definition: path.c:265

References canonicalize_path(), and newval.

◆ check_client_encoding()

bool check_client_encoding ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 688 of file variable.c.

689{
690 int encoding;
691 const char *canonical_name;
692
693 /* Look up the encoding by name */
695 if (encoding < 0)
696 return false;
697
698 /* Get the canonical name (no aliases, uniform case) */
699 canonical_name = pg_encoding_to_char(encoding);
700
701 /*
702 * Parallel workers send data to the leader, not the client. They always
703 * send data using the database encoding; therefore, we should never
704 * actually change the client encoding in a parallel worker. However,
705 * during parallel worker startup, we want to accept the leader's
706 * client_encoding setting so that anyone who looks at the value in the
707 * worker sees the same value that they would see in the leader. A change
708 * other than during startup, for example due to a SET clause attached to
709 * a function definition, should be rejected, as there is nothing we can
710 * do inside the worker to make it take effect.
711 */
713 {
714 GUC_check_errcode(ERRCODE_INVALID_TRANSACTION_STATE);
715 GUC_check_errdetail("Cannot change \"client_encoding\" during a parallel operation.");
716 return false;
717 }
718
719 /*
720 * If we are not within a transaction then PrepareClientEncoding will not
721 * be able to look up the necessary conversion procs. If we are still
722 * starting up, it will return "OK" anyway, and InitializeClientEncoding
723 * will fix things once initialization is far enough along. After
724 * startup, we'll fail. This would only happen if someone tries to change
725 * client_encoding in postgresql.conf and then SIGHUP existing sessions.
726 * It seems like a bad idea for client_encoding to change that way anyhow,
727 * so we don't go out of our way to support it.
728 *
729 * In a parallel worker, we might as well skip PrepareClientEncoding since
730 * we're not going to use its results.
731 *
732 * Note: in the postmaster, or any other process that never calls
733 * InitializeClientEncoding, PrepareClientEncoding will always succeed,
734 * and so will SetClientEncoding; but they won't do anything, which is OK.
735 */
736 if (!IsParallelWorker() &&
738 {
739 if (IsTransactionState())
740 {
741 /* Must be a genuine no-such-conversion problem */
742 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
743 GUC_check_errdetail("Conversion between %s and %s is not supported.",
744 canonical_name,
746 }
747 else
748 {
749 /* Provide a useful complaint */
750 GUC_check_errdetail("Cannot change \"client_encoding\" now.");
751 }
752 return false;
753 }
754
755 /*
756 * Replace the user-supplied string with the encoding's canonical name.
757 * This gets rid of aliases and case-folding variations.
758 *
759 * XXX Although canonicalizing seems like a good idea in the abstract, it
760 * breaks pre-9.1 JDBC drivers, which expect that if they send "UNICODE"
761 * as the client_encoding setting then it will read back the same way. As
762 * a workaround, don't replace the string if it's "UNICODE". Remove that
763 * hack when pre-9.1 JDBC drivers are no longer in use.
764 */
765 if (strcmp(*newval, canonical_name) != 0 &&
766 strcmp(*newval, "UNICODE") != 0)
767 {
769 *newval = guc_strdup(LOG, canonical_name);
770 if (!*newval)
771 return false;
772 }
773
774 /*
775 * Save the encoding's ID in *extra, for use by assign_client_encoding.
776 */
777 *extra = guc_malloc(LOG, sizeof(int));
778 if (!*extra)
779 return false;
780 *((int *) *extra) = encoding;
781
782 return true;
783}
bool InitializingParallelWorker
Definition: parallel.c:120
int pg_valid_client_encoding(const char *name)
Definition: encnames.c:485
void GUC_check_errcode(int sqlerrcode)
Definition: guc.c:6785
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:638
#define GUC_check_errdetail
Definition: guc.h:476
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1267
int PrepareClientEncoding(int encoding)
Definition: mbutils.c:110
#define pg_encoding_to_char
Definition: pg_wchar.h:630
bool IsTransactionState(void)
Definition: xact.c:386

References encoding, GetDatabaseEncodingName(), GUC_check_errcode(), GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), InitializingParallelWorker, IsParallelWorker, IsTransactionState(), LOG, newval, pg_encoding_to_char, pg_valid_client_encoding(), and PrepareClientEncoding().

◆ check_cluster_name()

bool check_cluster_name ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1118 of file variable.c.

1119{
1120 char *clean;
1121 char *ret;
1122
1123 /* Only allow clean ASCII chars in the cluster name */
1125 if (!clean)
1126 return false;
1127
1128 ret = guc_strdup(WARNING, clean);
1129 if (!ret)
1130 {
1131 pfree(clean);
1132 return false;
1133 }
1134
1135 guc_free(*newval);
1136
1137 pfree(clean);
1138 *newval = ret;
1139 return true;
1140}

References guc_free(), guc_strdup(), MCXT_ALLOC_NO_OOM, newval, pfree(), pg_clean_ascii(), and WARNING.

◆ check_datestyle()

bool check_datestyle ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 52 of file variable.c.

53{
54 int newDateStyle = DateStyle;
55 int newDateOrder = DateOrder;
56 bool have_style = false;
57 bool have_order = false;
58 bool ok = true;
59 char *rawstring;
60 int *myextra;
61 char *result;
62 List *elemlist;
63 ListCell *l;
64
65 /* Need a modifiable copy of string */
66 rawstring = pstrdup(*newval);
67
68 /* Parse string into list of identifiers */
69 if (!SplitIdentifierString(rawstring, ',', &elemlist))
70 {
71 /* syntax error in list */
72 GUC_check_errdetail("List syntax is invalid.");
73 pfree(rawstring);
74 list_free(elemlist);
75 return false;
76 }
77
78 foreach(l, elemlist)
79 {
80 char *tok = (char *) lfirst(l);
81
82 /* Ugh. Somebody ought to write a table driven version -- mjl */
83
84 if (pg_strcasecmp(tok, "ISO") == 0)
85 {
86 if (have_style && newDateStyle != USE_ISO_DATES)
87 ok = false; /* conflicting styles */
88 newDateStyle = USE_ISO_DATES;
89 have_style = true;
90 }
91 else if (pg_strcasecmp(tok, "SQL") == 0)
92 {
93 if (have_style && newDateStyle != USE_SQL_DATES)
94 ok = false; /* conflicting styles */
95 newDateStyle = USE_SQL_DATES;
96 have_style = true;
97 }
98 else if (pg_strncasecmp(tok, "POSTGRES", 8) == 0)
99 {
100 if (have_style && newDateStyle != USE_POSTGRES_DATES)
101 ok = false; /* conflicting styles */
102 newDateStyle = USE_POSTGRES_DATES;
103 have_style = true;
104 }
105 else if (pg_strcasecmp(tok, "GERMAN") == 0)
106 {
107 if (have_style && newDateStyle != USE_GERMAN_DATES)
108 ok = false; /* conflicting styles */
109 newDateStyle = USE_GERMAN_DATES;
110 have_style = true;
111 /* GERMAN also sets DMY, unless explicitly overridden */
112 if (!have_order)
113 newDateOrder = DATEORDER_DMY;
114 }
115 else if (pg_strcasecmp(tok, "YMD") == 0)
116 {
117 if (have_order && newDateOrder != DATEORDER_YMD)
118 ok = false; /* conflicting orders */
119 newDateOrder = DATEORDER_YMD;
120 have_order = true;
121 }
122 else if (pg_strcasecmp(tok, "DMY") == 0 ||
123 pg_strncasecmp(tok, "EURO", 4) == 0)
124 {
125 if (have_order && newDateOrder != DATEORDER_DMY)
126 ok = false; /* conflicting orders */
127 newDateOrder = DATEORDER_DMY;
128 have_order = true;
129 }
130 else if (pg_strcasecmp(tok, "MDY") == 0 ||
131 pg_strcasecmp(tok, "US") == 0 ||
132 pg_strncasecmp(tok, "NONEURO", 7) == 0)
133 {
134 if (have_order && newDateOrder != DATEORDER_MDY)
135 ok = false; /* conflicting orders */
136 newDateOrder = DATEORDER_MDY;
137 have_order = true;
138 }
139 else if (pg_strcasecmp(tok, "DEFAULT") == 0)
140 {
141 /*
142 * Easiest way to get the current DEFAULT state is to fetch the
143 * DEFAULT string from guc.c and recursively parse it.
144 *
145 * We can't simply "return check_datestyle(...)" because we need
146 * to handle constructs like "DEFAULT, ISO".
147 */
148 char *subval;
149 void *subextra = NULL;
150
151 subval = guc_strdup(LOG, GetConfigOptionResetString("datestyle"));
152 if (!subval)
153 {
154 ok = false;
155 break;
156 }
157 if (!check_datestyle(&subval, &subextra, source))
158 {
159 guc_free(subval);
160 ok = false;
161 break;
162 }
163 myextra = (int *) subextra;
164 if (!have_style)
165 newDateStyle = myextra[0];
166 if (!have_order)
167 newDateOrder = myextra[1];
168 guc_free(subval);
169 guc_free(subextra);
170 }
171 else
172 {
173 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
174 pfree(rawstring);
175 list_free(elemlist);
176 return false;
177 }
178 }
179
180 pfree(rawstring);
181 list_free(elemlist);
182
183 if (!ok)
184 {
185 GUC_check_errdetail("Conflicting \"DateStyle\" specifications.");
186 return false;
187 }
188
189 /*
190 * Prepare the canonical string to return. GUC wants it guc_malloc'd.
191 */
192 result = (char *) guc_malloc(LOG, 32);
193 if (!result)
194 return false;
195
196 switch (newDateStyle)
197 {
198 case USE_ISO_DATES:
199 strcpy(result, "ISO");
200 break;
201 case USE_SQL_DATES:
202 strcpy(result, "SQL");
203 break;
204 case USE_GERMAN_DATES:
205 strcpy(result, "German");
206 break;
207 default:
208 strcpy(result, "Postgres");
209 break;
210 }
211 switch (newDateOrder)
212 {
213 case DATEORDER_YMD:
214 strcat(result, ", YMD");
215 break;
216 case DATEORDER_DMY:
217 strcat(result, ", DMY");
218 break;
219 default:
220 strcat(result, ", MDY");
221 break;
222 }
223
225 *newval = result;
226
227 /*
228 * Set up the "extra" struct actually used by assign_datestyle.
229 */
230 myextra = (int *) guc_malloc(LOG, 2 * sizeof(int));
231 if (!myextra)
232 return false;
233 myextra[0] = newDateStyle;
234 myextra[1] = newDateOrder;
235 *extra = myextra;
236
237 return true;
238}
bool check_datestyle(char **newval, void **extra, GucSource source)
Definition: variable.c:52
const char * GetConfigOptionResetString(const char *name)
Definition: guc.c:4405
void list_free(List *list)
Definition: list.c:1546
char * pstrdup(const char *in)
Definition: mcxt.c:1696
#define USE_SQL_DATES
Definition: miscadmin.h:237
#define USE_POSTGRES_DATES
Definition: miscadmin.h:235
#define USE_ISO_DATES
Definition: miscadmin.h:236
#define DATEORDER_DMY
Definition: miscadmin.h:243
#define DATEORDER_MDY
Definition: miscadmin.h:244
#define DATEORDER_YMD
Definition: miscadmin.h:242
#define USE_GERMAN_DATES
Definition: miscadmin.h:238
#define lfirst(lc)
Definition: pg_list.h:172
static rewind_source * source
Definition: pg_rewind.c:89
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: pgstrcasecmp.c:69
Definition: pg_list.h:54
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3432

References check_datestyle(), DateOrder, DATEORDER_DMY, DATEORDER_MDY, DATEORDER_YMD, DateStyle, GetConfigOptionResetString(), GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), lfirst, list_free(), LOG, newval, pfree(), pg_strcasecmp(), pg_strncasecmp(), pstrdup(), source, SplitIdentifierString(), USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.

Referenced by check_datestyle().

◆ check_default_with_oids()

bool check_default_with_oids ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1220 of file variable.c.

1221{
1222 if (*newval)
1223 {
1224 /* check the GUC's definition for an explanation */
1225 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
1226 GUC_check_errmsg("tables declared WITH OIDS are not supported");
1227
1228 return false;
1229 }
1230
1231 return true;
1232}

References GUC_check_errcode(), GUC_check_errmsg, and newval.

◆ check_effective_io_concurrency()

bool check_effective_io_concurrency ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1235 of file variable.c.

1236{
1237#ifndef USE_PREFETCH
1238 if (*newval != 0)
1239 {
1240 GUC_check_errdetail("\"%s\" must be set to 0 on platforms that lack support for issuing read-ahead advice.",
1241 "effective_io_concurrency");
1242 return false;
1243 }
1244#endif /* USE_PREFETCH */
1245 return true;
1246}

References GUC_check_errdetail, and newval.

◆ check_log_timezone()

bool check_log_timezone ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 418 of file variable.c.

419{
420 pg_tz *new_tz;
421
422 /*
423 * Assume it is a timezone name, and try to load it.
424 */
425 new_tz = pg_tzset(*newval);
426
427 if (!new_tz)
428 {
429 /* Doesn't seem to be any great value in errdetail here */
430 return false;
431 }
432
433 if (!pg_tz_acceptable(new_tz))
434 {
435 GUC_check_errmsg("time zone \"%s\" appears to use leap seconds",
436 *newval);
437 GUC_check_errdetail("PostgreSQL does not support leap seconds.");
438 return false;
439 }
440
441 /*
442 * Pass back data for assign_log_timezone to use
443 */
444 *extra = guc_malloc(LOG, sizeof(pg_tz *));
445 if (!*extra)
446 return false;
447 *((pg_tz **) *extra) = new_tz;
448
449 return true;
450}
bool pg_tz_acceptable(pg_tz *tz)
Definition: localtime.c:2004
pg_tz * pg_tzset(const char *tzname)
Definition: pgtz.c:234

References GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), LOG, newval, pg_tz_acceptable(), and pg_tzset().

◆ check_maintenance_io_concurrency()

bool check_maintenance_io_concurrency ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1249 of file variable.c.

1250{
1251#ifndef USE_PREFETCH
1252 if (*newval != 0)
1253 {
1254 GUC_check_errdetail("\"%s\" must be set to 0 on platforms that lack support for issuing read-ahead advice.",
1255 "maintenance_io_concurrency");
1256 return false;
1257 }
1258#endif /* USE_PREFETCH */
1259 return true;
1260}

References GUC_check_errdetail, and newval.

◆ check_random_seed()

bool check_random_seed ( double *  newval,
void **  extra,
GucSource  source 
)

Definition at line 656 of file variable.c.

657{
658 *extra = guc_malloc(LOG, sizeof(int));
659 if (!*extra)
660 return false;
661 /* Arm the assign only if source of value is an interactive SET */
662 *((int *) *extra) = (source >= PGC_S_INTERACTIVE);
663
664 return true;
665}
@ PGC_S_INTERACTIVE
Definition: guc.h:120

References guc_malloc(), LOG, PGC_S_INTERACTIVE, and source.

◆ check_role()

bool check_role ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 933 of file variable.c.

934{
935 HeapTuple roleTup;
936 Oid roleid;
937 bool is_superuser;
938 role_auth_extra *myextra;
939 Form_pg_authid roleform;
940
941 if (strcmp(*newval, "none") == 0)
942 {
943 /* hardwired translation */
944 roleid = InvalidOid;
945 is_superuser = false;
946 }
948 {
949 /*
950 * In parallel worker initialization, we want to copy the leader's
951 * state even if it no longer matches the catalogs. ParallelWorkerMain
952 * already installed the correct role OID and superuser state.
953 */
954 roleid = GetCurrentRoleId();
956 }
957 else
958 {
959 if (!IsTransactionState())
960 {
961 /*
962 * Can't do catalog lookups, so fail. The result of this is that
963 * role cannot be set in postgresql.conf, which seems like a good
964 * thing anyway, so we don't work hard to avoid it.
965 */
966 return false;
967 }
968
969 /*
970 * When source == PGC_S_TEST, we don't throw a hard error for a
971 * nonexistent user name or insufficient privileges, only a NOTICE.
972 * See comments in guc.h.
973 */
974
975 /* Look up the username */
976 roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(*newval));
977 if (!HeapTupleIsValid(roleTup))
978 {
979 if (source == PGC_S_TEST)
980 {
982 (errcode(ERRCODE_UNDEFINED_OBJECT),
983 errmsg("role \"%s\" does not exist", *newval)));
984 return true;
985 }
986 GUC_check_errmsg("role \"%s\" does not exist", *newval);
987 return false;
988 }
989
990 roleform = (Form_pg_authid) GETSTRUCT(roleTup);
991 roleid = roleform->oid;
992 is_superuser = roleform->rolsuper;
993
994 ReleaseSysCache(roleTup);
995
996 /* Verify that session user is allowed to become this role */
998 {
999 if (source == PGC_S_TEST)
1000 {
1002 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1003 errmsg("permission will be denied to set role \"%s\"",
1004 *newval)));
1005 return true;
1006 }
1007 GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);
1008 GUC_check_errmsg("permission denied to set role \"%s\"",
1009 *newval);
1010 return false;
1011 }
1012 }
1013
1014 /* Set up "extra" struct for assign_role to use */
1015 myextra = (role_auth_extra *) guc_malloc(LOG, sizeof(role_auth_extra));
1016 if (!myextra)
1017 return false;
1018 myextra->roleid = roleid;
1019 myextra->is_superuser = is_superuser;
1020 *extra = myextra;
1021
1022 return true;
1023}
bool member_can_set_role(Oid member, Oid role)
Definition: acl.c:5302
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define NOTICE
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:149
@ PGC_S_TEST
Definition: guc.h:121
bool current_role_is_superuser
Definition: guc_tables.c:519
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
Oid GetSessionUserId(void)
Definition: miscinit.c:556
Oid GetCurrentRoleId(void)
Definition: miscinit.c:983
FormData_pg_authid * Form_pg_authid
Definition: pg_authid.h:56
static bool is_superuser(Archive *fout)
Definition: pg_dump.c:4806
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221

References current_role_is_superuser, ereport, errcode(), errmsg(), GetCurrentRoleId(), GetSessionUserId(), GETSTRUCT, GUC_check_errcode(), GUC_check_errmsg, guc_malloc(), HeapTupleIsValid, InitializingParallelWorker, InvalidOid, role_auth_extra::is_superuser, is_superuser(), IsTransactionState(), LOG, member_can_set_role(), newval, NOTICE, PGC_S_TEST, PointerGetDatum(), ReleaseSysCache(), role_auth_extra::roleid, SearchSysCache1(), and source.

◆ check_session_authorization()

bool check_session_authorization ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 815 of file variable.c.

816{
817 HeapTuple roleTup;
818 Form_pg_authid roleform;
819 Oid roleid;
820 bool is_superuser;
821 role_auth_extra *myextra;
822
823 /* Do nothing for the boot_val default of NULL */
824 if (*newval == NULL)
825 return true;
826
828 {
829 /*
830 * In parallel worker initialization, we want to copy the leader's
831 * state even if it no longer matches the catalogs. ParallelWorkerMain
832 * already installed the correct role OID and superuser state.
833 */
834 roleid = GetSessionUserId();
836 }
837 else
838 {
839 if (!IsTransactionState())
840 {
841 /*
842 * Can't do catalog lookups, so fail. The result of this is that
843 * session_authorization cannot be set in postgresql.conf, which
844 * seems like a good thing anyway, so we don't work hard to avoid
845 * it.
846 */
847 return false;
848 }
849
850 /*
851 * When source == PGC_S_TEST, we don't throw a hard error for a
852 * nonexistent user name or insufficient privileges, only a NOTICE.
853 * See comments in guc.h.
854 */
855
856 /* Look up the username */
857 roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(*newval));
858 if (!HeapTupleIsValid(roleTup))
859 {
860 if (source == PGC_S_TEST)
861 {
863 (errcode(ERRCODE_UNDEFINED_OBJECT),
864 errmsg("role \"%s\" does not exist", *newval)));
865 return true;
866 }
867 GUC_check_errmsg("role \"%s\" does not exist", *newval);
868 return false;
869 }
870
871 roleform = (Form_pg_authid) GETSTRUCT(roleTup);
872 roleid = roleform->oid;
873 is_superuser = roleform->rolsuper;
874
875 ReleaseSysCache(roleTup);
876
877 /*
878 * Only superusers may SET SESSION AUTHORIZATION a role other than
879 * itself. Note that in case of multiple SETs in a single session, the
880 * original authenticated user's superuserness is what matters.
881 */
882 if (roleid != GetAuthenticatedUserId() &&
884 {
885 if (source == PGC_S_TEST)
886 {
888 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
889 errmsg("permission will be denied to set session authorization \"%s\"",
890 *newval)));
891 return true;
892 }
893 GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);
894 GUC_check_errmsg("permission denied to set session authorization \"%s\"",
895 *newval);
896 return false;
897 }
898 }
899
900 /* Set up "extra" struct for assign_session_authorization to use */
901 myextra = (role_auth_extra *) guc_malloc(LOG, sizeof(role_auth_extra));
902 if (!myextra)
903 return false;
904 myextra->roleid = roleid;
905 myextra->is_superuser = is_superuser;
906 *extra = myextra;
907
908 return true;
909}
bool GetSessionUserIsSuperuser(void)
Definition: miscinit.c:563
Oid GetAuthenticatedUserId(void)
Definition: miscinit.c:593
bool superuser_arg(Oid roleid)
Definition: superuser.c:56

References ereport, errcode(), errmsg(), GetAuthenticatedUserId(), GetSessionUserId(), GetSessionUserIsSuperuser(), GETSTRUCT, GUC_check_errcode(), GUC_check_errmsg, guc_malloc(), HeapTupleIsValid, InitializingParallelWorker, role_auth_extra::is_superuser, is_superuser(), IsTransactionState(), LOG, newval, NOTICE, PGC_S_TEST, PointerGetDatum(), ReleaseSysCache(), role_auth_extra::roleid, SearchSysCache1(), source, and superuser_arg().

◆ check_ssl()

bool check_ssl ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1263 of file variable.c.

1264{
1265#ifndef USE_SSL
1266 if (*newval)
1267 {
1268 GUC_check_errmsg("SSL is not supported by this build");
1269 return false;
1270 }
1271#endif
1272 return true;
1273}

References GUC_check_errmsg, and newval.

◆ check_timezone()

bool check_timezone ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 261 of file variable.c.

262{
263 pg_tz *new_tz;
264 long gmtoffset;
265 char *endptr;
266 double hours;
267
268 if (pg_strncasecmp(*newval, "interval", 8) == 0)
269 {
270 /*
271 * Support INTERVAL 'foo'. This is for SQL spec compliance, not
272 * because it has any actual real-world usefulness.
273 */
274 const char *valueptr = *newval;
275 char *val;
277
278 valueptr += 8;
279 while (isspace((unsigned char) *valueptr))
280 valueptr++;
281 if (*valueptr++ != '\'')
282 return false;
283 val = pstrdup(valueptr);
284 /* Check and remove trailing quote */
285 endptr = strchr(val, '\'');
286 if (!endptr || endptr[1] != '\0')
287 {
288 pfree(val);
289 return false;
290 }
291 *endptr = '\0';
292
293 /*
294 * Try to parse it. XXX an invalid interval format will result in
295 * ereport(ERROR), which is not desirable for GUC. We did what we
296 * could to guard against this in flatten_set_variable_args, but a
297 * string coming in from postgresql.conf might contain anything.
298 */
302 Int32GetDatum(-1)));
303
304 pfree(val);
305 if (interval->month != 0)
306 {
307 GUC_check_errdetail("Cannot specify months in time zone interval.");
309 return false;
310 }
311 if (interval->day != 0)
312 {
313 GUC_check_errdetail("Cannot specify days in time zone interval.");
315 return false;
316 }
317
318 /* Here we change from SQL to Unix sign convention */
319 gmtoffset = -(interval->time / USECS_PER_SEC);
320 new_tz = pg_tzset_offset(gmtoffset);
321
323 }
324 else
325 {
326 /*
327 * Try it as a numeric number of hours (possibly fractional).
328 */
329 hours = strtod(*newval, &endptr);
330 if (endptr != *newval && *endptr == '\0')
331 {
332 /* Here we change from SQL to Unix sign convention */
333 gmtoffset = -hours * SECS_PER_HOUR;
334 new_tz = pg_tzset_offset(gmtoffset);
335 }
336 else
337 {
338 /*
339 * Otherwise assume it is a timezone name, and try to load it.
340 */
341 new_tz = pg_tzset(*newval);
342
343 if (!new_tz)
344 {
345 /* Doesn't seem to be any great value in errdetail here */
346 return false;
347 }
348
349 if (!pg_tz_acceptable(new_tz))
350 {
351 GUC_check_errmsg("time zone \"%s\" appears to use leap seconds",
352 *newval);
353 GUC_check_errdetail("PostgreSQL does not support leap seconds.");
354 return false;
355 }
356 }
357 }
358
359 /* Test for failure in pg_tzset_offset, which we assume is out-of-range */
360 if (!new_tz)
361 {
362 GUC_check_errdetail("UTC timezone offset is out of range.");
363 return false;
364 }
365
366 /*
367 * Pass back data for assign_timezone to use
368 */
369 *extra = guc_malloc(LOG, sizeof(pg_tz *));
370 if (!*extra)
371 return false;
372 *((pg_tz **) *extra) = new_tz;
373
374 return true;
375}
Datum interval_in(PG_FUNCTION_ARGS)
Definition: timestamp.c:890
#define SECS_PER_HOUR
Definition: timestamp.h:127
#define USECS_PER_SEC
Definition: timestamp.h:134
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:645
long val
Definition: informix.c:689
pg_tz * pg_tzset_offset(long gmtoffset)
Definition: pgtz.c:320
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:257
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:355
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:217
static Interval * DatumGetIntervalP(Datum X)
Definition: timestamp.h:40

References CStringGetDatum(), DatumGetIntervalP(), DirectFunctionCall3, GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), Int32GetDatum(), interval_in(), InvalidOid, LOG, interval::month, newval, ObjectIdGetDatum(), pfree(), pg_strncasecmp(), pg_tz_acceptable(), pg_tzset(), pg_tzset_offset(), pstrdup(), SECS_PER_HOUR, interval::time, USECS_PER_SEC, and val.

◆ check_timezone_abbreviations()

bool check_timezone_abbreviations ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 487 of file variable.c.

488{
489 /*
490 * The boot_val for timezone_abbreviations is NULL. When we see that we
491 * just do nothing. If the value isn't overridden from the config file
492 * then pg_timezone_abbrev_initialize() will eventually replace it with
493 * "Default". This hack has two purposes: to avoid wasting cycles loading
494 * values that might soon be overridden from the config file, and to avoid
495 * trying to read the timezone abbrev files during InitializeGUCOptions().
496 * The latter doesn't work in an EXEC_BACKEND subprocess because
497 * my_exec_path hasn't been set yet and so we can't locate PGSHAREDIR.
498 */
499 if (*newval == NULL)
500 {
502 return true;
503 }
504
505 /* OK, load the file and produce a guc_malloc'd TimeZoneAbbrevTable */
506 *extra = load_tzoffsets(*newval);
507
508 /* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
509 if (!*extra)
510 return false;
511
512 return true;
513}
#define Assert(condition)
Definition: c.h:815
@ PGC_S_DEFAULT
Definition: guc.h:109
TimeZoneAbbrevTable * load_tzoffsets(const char *filename)
Definition: tzparser.c:449

References Assert, load_tzoffsets(), newval, PGC_S_DEFAULT, and source.

◆ check_transaction_deferrable()

bool check_transaction_deferrable ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 624 of file variable.c.

625{
626 /* Just accept the value when restoring state in a parallel worker */
628 return true;
629
630 if (IsSubTransaction())
631 {
632 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
633 GUC_check_errmsg("SET TRANSACTION [NOT] DEFERRABLE cannot be called within a subtransaction");
634 return false;
635 }
637 {
638 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
639 GUC_check_errmsg("SET TRANSACTION [NOT] DEFERRABLE must be called before any query");
640 return false;
641 }
642
643 return true;
644}
bool FirstSnapshotSet
Definition: snapmgr.c:133
bool IsSubTransaction(void)
Definition: xact.c:5036

References FirstSnapshotSet, GUC_check_errcode(), GUC_check_errmsg, InitializingParallelWorker, and IsSubTransaction().

◆ check_transaction_isolation()

bool check_transaction_isolation ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 586 of file variable.c.

587{
588 int newXactIsoLevel = *newval;
589
590 if (newXactIsoLevel != XactIsoLevel &&
592 {
594 {
595 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
596 GUC_check_errmsg("SET TRANSACTION ISOLATION LEVEL must be called before any query");
597 return false;
598 }
599 /* We ignore a subtransaction setting it to the existing value. */
600 if (IsSubTransaction())
601 {
602 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
603 GUC_check_errmsg("SET TRANSACTION ISOLATION LEVEL must not be called in a subtransaction");
604 return false;
605 }
606 /* Can't go to serializable mode while recovery is still active */
607 if (newXactIsoLevel == XACT_SERIALIZABLE && RecoveryInProgress())
608 {
609 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
610 GUC_check_errmsg("cannot use serializable mode in a hot standby");
611 GUC_check_errhint("You can use REPEATABLE READ instead.");
612 return false;
613 }
614 }
615
616 return true;
617}
#define GUC_check_errhint
Definition: guc.h:480
int XactIsoLevel
Definition: xact.c:78
#define XACT_SERIALIZABLE
Definition: xact.h:39
bool RecoveryInProgress(void)
Definition: xlog.c:6334

References FirstSnapshotSet, GUC_check_errcode(), GUC_check_errhint, GUC_check_errmsg, InitializingParallelWorker, IsSubTransaction(), IsTransactionState(), newval, RecoveryInProgress(), XACT_SERIALIZABLE, and XactIsoLevel.

◆ check_transaction_read_only()

bool check_transaction_read_only ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 546 of file variable.c.

547{
549 {
550 /* Can't go to r/w mode inside a r/o transaction */
551 if (IsSubTransaction())
552 {
553 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
554 GUC_check_errmsg("cannot set transaction read-write mode inside a read-only transaction");
555 return false;
556 }
557 /* Top level transaction can't change to r/w after first snapshot. */
559 {
560 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
561 GUC_check_errmsg("transaction read-write mode must be set before any query");
562 return false;
563 }
564 /* Can't go to r/w mode while recovery is still active */
565 if (RecoveryInProgress())
566 {
567 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
568 GUC_check_errmsg("cannot set transaction read-write mode during recovery");
569 return false;
570 }
571 }
572
573 return true;
574}
bool XactReadOnly
Definition: xact.c:81

References FirstSnapshotSet, GUC_check_errcode(), GUC_check_errmsg, InitializingParallelWorker, IsSubTransaction(), IsTransactionState(), newval, RecoveryInProgress(), and XactReadOnly.

◆ show_data_directory_mode()

const char * show_data_directory_mode ( void  )

Definition at line 1168 of file variable.c.

1169{
1170 static char buf[12];
1171
1172 snprintf(buf, sizeof(buf), "%04o", data_directory_mode);
1173 return buf;
1174}
int data_directory_mode
Definition: globals.c:76
static char * buf
Definition: pg_test_fsync.c:72
#define snprintf
Definition: port.h:238

References buf, data_directory_mode, and snprintf.

◆ show_log_file_mode()

const char * show_log_file_mode ( void  )

Definition at line 1180 of file variable.c.

1181{
1182 static char buf[12];
1183
1184 snprintf(buf, sizeof(buf), "%04o", Log_file_mode);
1185 return buf;
1186}
int Log_file_mode
Definition: syslogger.c:76

References buf, Log_file_mode, and snprintf.

◆ show_log_timezone()

const char * show_log_timezone ( void  )

Definition at line 465 of file variable.c.

466{
467 const char *tzn;
468
469 /* Always show the zone's canonical name */
471
472 if (tzn != NULL)
473 return tzn;
474
475 return "unknown";
476}
const char * pg_get_timezone_name(pg_tz *tz)
Definition: localtime.c:1989

References log_timezone, and pg_get_timezone_name().

◆ show_random_seed()

const char * show_random_seed ( void  )

Definition at line 677 of file variable.c.

678{
679 return "unavailable";
680}

◆ show_role()

const char * show_role ( void  )

Definition at line 1034 of file variable.c.

1035{
1036 /*
1037 * Check whether SET ROLE is active; if not return "none". This is a
1038 * kluge to deal with the fact that SET SESSION AUTHORIZATION logically
1039 * resets SET ROLE to NONE, but we cannot set the GUC role variable from
1040 * assign_session_authorization (because we haven't got enough info to
1041 * call set_config_option).
1042 */
1044 return "none";
1045
1046 /* Otherwise we can just use the GUC string */
1047 return role_string ? role_string : "none";
1048}
#define OidIsValid(objectId)
Definition: c.h:732
char * role_string
Definition: guc_tables.c:619

References GetCurrentRoleId(), OidIsValid, and role_string.

◆ show_timezone()

const char * show_timezone ( void  )

Definition at line 392 of file variable.c.

393{
394 const char *tzn;
395
396 /* Always show the zone's canonical name */
398
399 if (tzn != NULL)
400 return tzn;
401
402 return "unknown";
403}

References pg_get_timezone_name(), and session_timezone.

◆ show_unix_socket_permissions()

const char * show_unix_socket_permissions ( void  )

Definition at line 1192 of file variable.c.

1193{
1194 static char buf[12];
1195
1196 snprintf(buf, sizeof(buf), "%04o", Unix_socket_permissions);
1197 return buf;
1198}
int Unix_socket_permissions
Definition: pqcomm.c:106

References buf, snprintf, and Unix_socket_permissions.