contrib/adminpack/adminpack.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * adminpack.c
   4  *
   5  *
   6  * Copyright (c) 2002-2009, PostgreSQL Global Development Group
   7  *
   8  * Author: Andreas Pflug <pgadmin@pse-consulting.de>
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL$
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include <sys/file.h>
  18 #include <sys/stat.h>
  19 #include <unistd.h>
  20
  21 #include "catalog/pg_type.h"
  22 #include "funcapi.h"
  23 #include "miscadmin.h"
  24 #include "postmaster/syslogger.h"
  25 #include "storage/fd.h"
  26 #include "utils/builtins.h"
  27 #include "utils/datetime.h"
  28
  29
  30 #ifdef WIN32
  31
  32 #ifdef rename
  33 #undef rename
  34 #endif
  35
  36 #ifdef unlink
  37 #undef unlink
  38 #endif
  39 #endif
  40
  41 PG_MODULE_MAGIC;
  42
  43 Datum           pg_file_write(PG_FUNCTION_ARGS);
  44 Datum           pg_file_rename(PG_FUNCTION_ARGS);
  45 Datum           pg_file_unlink(PG_FUNCTION_ARGS);
  46 Datum           pg_logdir_ls(PG_FUNCTION_ARGS);
  47
  48 PG_FUNCTION_INFO_V1(pg_file_write);
  49 PG_FUNCTION_INFO_V1(pg_file_rename);
  50 PG_FUNCTION_INFO_V1(pg_file_unlink);
  51 PG_FUNCTION_INFO_V1(pg_logdir_ls);
  52
  53 typedef struct
  54 {
  55         char       *location;
  56         DIR                *dirdesc;
  57 } directory_fctx;
  58
  59 /*-----------------------
  60  * some helper functions
  61  */
  62
  63 /*
  64  * Convert a "text" filename argument to C string, and check it's allowable.
  65  *
  66  * Filename may be absolute or relative to the DataDir, but we only allow
  67  * absolute paths that match DataDir or Log_directory.
  68  */
  69 static char *
  70 convert_and_check_filename(text *arg, bool logAllowed)
  71 {
  72         char       *filename = text_to_cstring(arg);
  73
  74         canonicalize_path(filename);    /* filename can change length here */
  75
  76         /* Disallow ".." in the path */
  77         if (path_contains_parent_reference(filename))
  78                 ereport(ERROR,
  79                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
  80                         (errmsg("reference to parent directory (\"..\") not allowed"))));
  81
  82         if (is_absolute_path(filename))
  83         {
  84                 /* Allow absolute references within DataDir */
  85                 if (path_is_prefix_of_path(DataDir, filename))
  86                         return filename;
  87                 /* The log directory might be outside our datadir, but allow it */
  88                 if (logAllowed &&
  89                         is_absolute_path(Log_directory) &&
  90                         path_is_prefix_of_path(Log_directory, filename))
  91                         return filename;
  92
  93                 ereport(ERROR,
  94                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
  95                                  (errmsg("absolute path not allowed"))));
  96                 return NULL;                    /* keep compiler quiet */
  97         }
  98         else
  99         {
 100                 return filename;
 101         }
 102 }
 103
 104
 105 /*
 106  * check for superuser, bark if not.
 107  */
 108 static void
 109 requireSuperuser(void)
 110 {
 111         if (!superuser())
 112                 ereport(ERROR,
 113                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 114                           (errmsg("only superuser may access generic file functions"))));
 115 }
 116
 117
 118
 119 /* ------------------------------------
 120  * generic file handling functions
 121  */
 122
 123 Datum
 124 pg_file_write(PG_FUNCTION_ARGS)
 125 {
 126         FILE       *f;
 127         char       *filename;
 128         text       *data;
 129         int64           count = 0;
 130
 131         requireSuperuser();
 132
 133         filename = convert_and_check_filename(PG_GETARG_TEXT_P(0), false);
 134         data = PG_GETARG_TEXT_P(1);
 135
 136         if (!PG_GETARG_BOOL(2))
 137         {
 138                 struct stat fst;
 139
 140                 if (stat(filename, &fst) >= 0)
 141                         ereport(ERROR,
 142                                         (ERRCODE_DUPLICATE_FILE,
 143                                          errmsg("file \"%s\" exists", filename)));
 144
 145                 f = fopen(filename, "wb");
 146         }
 147         else
 148                 f = fopen(filename, "ab");
 149
 150         if (!f)
 151                 ereport(ERROR,
 152                                 (errcode_for_file_access(),
 153                                  errmsg("could not open file \"%s\" for writing: %m",
 154                                                 filename)));
 155
 156         if (VARSIZE(data) != 0)
 157         {
 158                 count = fwrite(VARDATA(data), 1, VARSIZE(data) - VARHDRSZ, f);
 159
 160                 if (count != VARSIZE(data) - VARHDRSZ)
 161                         ereport(ERROR,
 162                                         (errcode_for_file_access(),
 163                                          errmsg("could not write file \"%s\": %m", filename)));
 164         }
 165         fclose(f);
 166
 167         PG_RETURN_INT64(count);
 168 }
 169
 170
 171 Datum
 172 pg_file_rename(PG_FUNCTION_ARGS)
 173 {
 174         char       *fn1,
 175                            *fn2,
 176                            *fn3;
 177         int                     rc;
 178
 179         requireSuperuser();
 180
 181         if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
 182                 PG_RETURN_NULL();
 183
 184         fn1 = convert_and_check_filename(PG_GETARG_TEXT_P(0), false);
 185         fn2 = convert_and_check_filename(PG_GETARG_TEXT_P(1), false);
 186         if (PG_ARGISNULL(2))
 187                 fn3 = 0;
 188         else
 189                 fn3 = convert_and_check_filename(PG_GETARG_TEXT_P(2), false);
 190
 191         if (access(fn1, W_OK) < 0)
 192         {
 193                 ereport(WARNING,
 194                                 (errcode_for_file_access(),
 195                                  errmsg("file \"%s\" is not accessible: %m", fn1)));
 196
 197                 PG_RETURN_BOOL(false);
 198         }
 199
 200         if (fn3 && access(fn2, W_OK) < 0)
 201         {
 202                 ereport(WARNING,
 203                                 (errcode_for_file_access(),
 204                                  errmsg("file \"%s\" is not accessible: %m", fn2)));
 205
 206                 PG_RETURN_BOOL(false);
 207         }
 208
 209         rc = access(fn3 ? fn3 : fn2, 2);
 210         if (rc >= 0 || errno != ENOENT)
 211         {
 212                 ereport(ERROR,
 213                                 (ERRCODE_DUPLICATE_FILE,
 214                                  errmsg("cannot rename to target file \"%s\"",
 215                                                 fn3 ? fn3 : fn2)));
 216         }
 217
 218         if (fn3)
 219         {
 220                 if (rename(fn2, fn3) != 0)
 221                 {
 222                         ereport(ERROR,
 223                                         (errcode_for_file_access(),
 224                                          errmsg("could not rename \"%s\" to \"%s\": %m",
 225                                                         fn2, fn3)));
 226                 }
 227                 if (rename(fn1, fn2) != 0)
 228                 {
 229                         ereport(WARNING,
 230                                         (errcode_for_file_access(),
 231                                          errmsg("could not rename \"%s\" to \"%s\": %m",
 232                                                         fn1, fn2)));
 233
 234                         if (rename(fn3, fn2) != 0)
 235                         {
 236                                 ereport(ERROR,
 237                                                 (errcode_for_file_access(),
 238                                                  errmsg("could not rename \"%s\" back to \"%s\": %m",
 239                                                                 fn3, fn2)));
 240                         }
 241                         else
 242                         {
 243                                 ereport(ERROR,
 244                                                 (ERRCODE_UNDEFINED_FILE,
 245                                                  errmsg("renaming \"%s\" to \"%s\" was reverted",
 246                                                                 fn2, fn3)));
 247                         }
 248                 }
 249         }
 250         else if (rename(fn1, fn2) != 0)
 251         {
 252                 ereport(ERROR,
 253                                 (errcode_for_file_access(),
 254                                  errmsg("could not rename \"%s\" to \"%s\": %m", fn1, fn2)));
 255         }
 256
 257         PG_RETURN_BOOL(true);
 258 }
 259
 260
 261 Datum
 262 pg_file_unlink(PG_FUNCTION_ARGS)
 263 {
 264         char       *filename;
 265
 266         requireSuperuser();
 267
 268         filename = convert_and_check_filename(PG_GETARG_TEXT_P(0), false);
 269
 270         if (access(filename, W_OK) < 0)
 271         {
 272                 if (errno == ENOENT)
 273                         PG_RETURN_BOOL(false);
 274                 else
 275                         ereport(ERROR,
 276                                         (errcode_for_file_access(),
 277                                          errmsg("file \"%s\" is not accessible: %m", filename)));
 278         }
 279
 280         if (unlink(filename) < 0)
 281         {
 282                 ereport(WARNING,
 283                                 (errcode_for_file_access(),
 284                                  errmsg("could not unlink file \"%s\": %m", filename)));
 285
 286                 PG_RETURN_BOOL(false);
 287         }
 288         PG_RETURN_BOOL(true);
 289 }
 290
 291
 292 Datum
 293 pg_logdir_ls(PG_FUNCTION_ARGS)
 294 {
 295         FuncCallContext *funcctx;
 296         struct dirent *de;
 297         directory_fctx *fctx;
 298
 299         if (!superuser())
 300                 ereport(ERROR,
 301                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 302                                  (errmsg("only superuser can list the log directory"))));
 303
 304         if (strcmp(Log_filename, "postgresql-%Y-%m-%d_%H%M%S.log") != 0)
 305                 ereport(ERROR,
 306                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 307                                  (errmsg("the log_filename parameter must equal 'postgresql-%%Y-%%m-%%d_%%H%%M%%S.log'"))));
 308
 309         if (SRF_IS_FIRSTCALL())
 310         {
 311                 MemoryContext oldcontext;
 312                 TupleDesc       tupdesc;
 313
 314                 funcctx = SRF_FIRSTCALL_INIT();
 315                 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 316
 317                 fctx = palloc(sizeof(directory_fctx));
 318
 319                 tupdesc = CreateTemplateTupleDesc(2, false);
 320                 TupleDescInitEntry(tupdesc, (AttrNumber) 1, "starttime",
 321                                                    TIMESTAMPOID, -1, 0);
 322                 TupleDescInitEntry(tupdesc, (AttrNumber) 2, "filename",
 323                                                    TEXTOID, -1, 0);
 324
 325                 funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);
 326
 327                 fctx->location = pstrdup(Log_directory);
 328                 fctx->dirdesc = AllocateDir(fctx->location);
 329
 330                 if (!fctx->dirdesc)
 331                         ereport(ERROR,
 332                                         (errcode_for_file_access(),
 333                                          errmsg("could not read directory \"%s\": %m",
 334                                                         fctx->location)));
 335
 336                 funcctx->user_fctx = fctx;
 337                 MemoryContextSwitchTo(oldcontext);
 338         }
 339
 340         funcctx = SRF_PERCALL_SETUP();
 341         fctx = (directory_fctx *) funcctx->user_fctx;
 342
 343         while ((de = ReadDir(fctx->dirdesc, fctx->location)) != NULL)
 344         {
 345                 char       *values[2];
 346                 HeapTuple       tuple;
 347                 char            timestampbuf[32];
 348                 char       *field[MAXDATEFIELDS];
 349                 char            lowstr[MAXDATELEN + 1];
 350                 int                     dtype;
 351                 int                     nf,
 352                                         ftype[MAXDATEFIELDS];
 353                 fsec_t          fsec;
 354                 int                     tz = 0;
 355                 struct pg_tm date;
 356
 357                 /*
 358                  * Default format: postgresql-YYYY-MM-DD_HHMMSS.log
 359                  */
 360                 if (strlen(de->d_name) != 32
 361                         || strncmp(de->d_name, "postgresql-", 11) != 0
 362                         || de->d_name[21] != '_'
 363                         || strcmp(de->d_name + 28, ".log") != 0)
 364                         continue;
 365
 366                 /* extract timestamp portion of filename */
 367                 strcpy(timestampbuf, de->d_name + 11);
 368                 timestampbuf[17] = '\0';
 369
 370                 /* parse and decode expected timestamp to verify it's OK format */
 371                 if (ParseDateTime(timestampbuf, lowstr, MAXDATELEN, field, ftype, MAXDATEFIELDS, &nf))
 372                         continue;
 373
 374                 if (DecodeDateTime(field, ftype, nf, &dtype, &date, &fsec, &tz))
 375                         continue;
 376
 377                 /* Seems the timestamp is OK; prepare and return tuple */
 378
 379                 values[0] = timestampbuf;
 380                 values[1] = palloc(strlen(fctx->location) + strlen(de->d_name) + 2);
 381                 sprintf(values[1], "%s/%s", fctx->location, de->d_name);
 382
 383                 tuple = BuildTupleFromCStrings(funcctx->attinmeta, values);
 384
 385                 SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
 386         }
 387
 388         FreeDir(fctx->dirdesc);
 389         SRF_RETURN_DONE(funcctx);
 390 }