/*

* Attention - this functionality doesn't work when Orace is not linked with

* correct runtime library. The combination "vcruntime140.dll" is working for

* PostgreSQL 12 (vcruntime140d.dll doesn't work). Probably this runtime should

* be same like Postgres server runtime (what is used can be detected by

* dependency walker). Without correct linking the server crash when IO related

* functionality is used.

*/

#ifdef _MSC_VER

#define _CRT_SECURE_NO_DEPRECATE

#endif

#include "postgres.h"

#include <errno.h>

#include <unistd.h>

#include <sys/stat.h>

#include "executor/spi.h"

#include "access/htup_details.h"

#include "catalog/pg_type.h"

#include "fmgr.h"

#include "funcapi.h"

#include "mb/pg_wchar.h"

#include "miscadmin.h"

#include "port.h"

#include "storage/fd.h"

#include "utils/acl.h"

#include "utils/builtins.h"

#include "utils/memutils.h"

#ifdef WIN32

#include "utils/pg_locale.h"

#endif

#include "orafce.h"

#include "builtins.h"

#ifndef ERRCODE_NO_DATA_FOUND

#define ERRCODE_NO_DATA_FOUND MAKE_SQLSTATE('P','0', '0','0','2')

#endif

#define INVALID_OPERATION "UTL_FILE_INVALID_OPERATION"

#define WRITE_ERROR "UTL_FILE_WRITE_ERROR"

#define READ_ERROR "UTL_FILE_READ_ERROR"

#define INVALID_FILEHANDLE "UTL_FILE_INVALID_FILEHANDLE"

#define INVALID_MAXLINESIZE "UTL_FILE_INVALID_MAXLINESIZE"

#define INVALID_MODE "UTL_FILE_INVALID_MODE"

#define INVALID_PATH "UTL_FILE_INVALID_PATH"

#define VALUE_ERROR "UTL_FILE_VALUE_ERROR"

PG_FUNCTION_INFO_V1(utl_file_fopen);

PG_FUNCTION_INFO_V1(utl_file_is_open);

PG_FUNCTION_INFO_V1(utl_file_get_line);

PG_FUNCTION_INFO_V1(utl_file_get_nextline);

PG_FUNCTION_INFO_V1(utl_file_put);

PG_FUNCTION_INFO_V1(utl_file_put_line);

PG_FUNCTION_INFO_V1(utl_file_new_line);

PG_FUNCTION_INFO_V1(utl_file_putf);

PG_FUNCTION_INFO_V1(utl_file_fflush);

PG_FUNCTION_INFO_V1(utl_file_fclose);

PG_FUNCTION_INFO_V1(utl_file_fclose_all);

PG_FUNCTION_INFO_V1(utl_file_fremove);

PG_FUNCTION_INFO_V1(utl_file_frename);

PG_FUNCTION_INFO_V1(utl_file_fcopy);

PG_FUNCTION_INFO_V1(utl_file_fgetattr);

PG_FUNCTION_INFO_V1(utl_file_tmpdir);

#define CUSTOM_EXCEPTION(msg, detail) \

ereport(ERROR, \

(errcode(ERRCODE_RAISE_EXCEPTION), \

errmsg("%s", msg), \

errdetail("%s", detail)))

#define STRERROR_EXCEPTION(msg) \

do { char *strerr = strerror(errno); CUSTOM_EXCEPTION(msg, strerr); } while(0);

#define INVALID_FILEHANDLE_EXCEPTION() CUSTOM_EXCEPTION(INVALID_FILEHANDLE, "Used file handle isn't valid.")

#define CHECK_FILE_HANDLE() \

if (PG_ARGISNULL(0)) \

CUSTOM_EXCEPTION(INVALID_FILEHANDLE, "Used file handle isn't valid.")

#define NON_EMPTY_TEXT(dat) \

if (VARSIZE(dat) - VARHDRSZ == 0) \

ereport(ERROR, \

(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \

errmsg("invalid parameter"), \

errdetail("Empty string isn't allowed.")));

#define NOT_NULL_ARG(n) \

if (PG_ARGISNULL(n)) \

ereport(ERROR, \

(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), \

errmsg("null value not allowed"), \

errhint("%dth argument is NULL.", n)));

#define MAX_LINESIZE 32767

#define CHECK_LINESIZE(max_linesize) \

do { \

if ((max_linesize) < 1 || (max_linesize) > MAX_LINESIZE) \

CUSTOM_EXCEPTION(INVALID_MAXLINESIZE, "maxlinesize is out of range"); \

} while(0)

typedef struct FileSlot

{

FILE *file;

int max_linesize;

int encoding;

int32 id;

} FileSlot;

#define MAX_SLOTS 50 /* Oracle 10g supports 50 files */

#define INVALID_SLOTID 0 /* invalid slot id */

static FileSlot slots[MAX_SLOTS]; /* initilaized with zeros */

static int32 slotid = 0; /* next slot id */

static void check_secure_locality(const char *path);

static char *get_safe_path(text *location, text *filename);

static int copy_text_file(FILE *srcfile, FILE *dstfile,

int start_line, int end_line);

static int orafce_umask = 077;

char *orafce_umask_str = NULL;

static Oid orafce_set_umask_roleid = InvalidOid;

void

orafce_umask_assign_hook(const char *newvalue, void *extra)

{

orafce_umask = *((int *) extra);

}

bool

orafce_umask_check_hook(char **newval, void **extra, GucSource source)

{

int digits = 0;

char *ptr = *newval;

int *myextra;

if (orafce_initialized && IsNormalProcessingMode() && IsTransactionState())

{

if (!superuser())

{

if (!OidIsValid(orafce_set_umask_roleid))

orafce_set_umask_roleid = get_role_oid("orafce_set_umask", false);

if (!has_privs_of_role(GetUserId(), orafce_set_umask_roleid))

{

GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);

GUC_check_errmsg("permission denied to set \"orafce.umask\"");

GUC_check_errdetail("Only roles with privileges of the \"orafce_set_umask\" can set \"orafce.umask\".");

return false;

}

}

}

while (*ptr)

{

if (*ptr < '0' || *ptr > '7')

{

GUC_check_errdetail("invalid octal digit");

return false;

}

if (digits > 3)

{

GUC_check_errdetail("number is too big (only four digits are allowed");

return false;

}

ptr++;

digits++;

}

#if PG_VERSION_NUM >= 160000

myextra = (int *) guc_malloc(LOG, sizeof(int));

#else

myextra = (int *) malloc(sizeof(int));

#endif

if (!myextra)

return false;

*myextra = (int) strtol(*newval, NULL, 8);

*extra = (void *) myextra;

return true;

}

/*

* get_descriptor(FILE *file) find any free slot for FILE pointer.

* If isn't realloc array slots and add 32 new free slots.

*

*/

static int

get_descriptor(FILE *file, int max_linesize, int encoding)

{

int i;

for (i = 0; i < MAX_SLOTS; i++)

{

if (slots[i].id == INVALID_SLOTID)

{

slots[i].id = ++slotid;

if (slots[i].id == INVALID_SLOTID)

slots[i].id = ++slotid; /* skip INVALID_SLOTID */

slots[i].file = file;

slots[i].max_linesize = max_linesize;

slots[i].encoding = encoding;

return slots[i].id;

}

}

return INVALID_SLOTID;

}

/* return stored pointer to FILE */

static FILE *

get_stream(int d, size_t *max_linesize, int *encoding)

{

int i;

if (d == INVALID_SLOTID)

INVALID_FILEHANDLE_EXCEPTION();

for (i = 0; i < MAX_SLOTS; i++)

{

if (slots[i].id == d)

{

if (max_linesize)

*max_linesize = slots[i].max_linesize;

if (encoding)

*encoding = slots[i].encoding;

return slots[i].file;

}

}

INVALID_FILEHANDLE_EXCEPTION();

return NULL; /* keep compiler quiet */

}

static void

IO_EXCEPTION(void)

{

switch (errno)

{

case EACCES:

case ENAMETOOLONG:

case ENOENT:

case ENOTDIR:

STRERROR_EXCEPTION(INVALID_PATH);

break;

default:

STRERROR_EXCEPTION(INVALID_OPERATION);

}

}

/*

* On WIN32 platform multibyte chars are not supported by

* fopen function. Instead we can use _wfopen functin. The

* arguments are of wchar strings, and should to use UTF16

* charset. Conversion from server encoding to wide strings

* is provided by function char2wchar (tested only for UTF8)

*/

#ifdef WIN32

static wchar_t *

to_wchar(const char *str)

{

size_t nbytes;

wchar_t *buff;

nbytes = strlen(str);

if ((nbytes + 1) > INT_MAX / sizeof(wchar_t))

ereport(ERROR,

(errcode(ERRCODE_OUT_OF_MEMORY),

errmsg("out of memory")));

buff = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));

char2wchar(buff, nbytes + 1, str, nbytes, 0);

return buff;

}

#endif

/*

* FUNCTION UTL_FILE.FOPEN(location text,

* filename text,

* open_mode text,

* max_linesize integer

* [, encoding text ])

* RETURNS UTL_FILE.FILE_TYPE;

*

* The FOPEN function opens specified file and returns file handle.

* open_mode: ['R', 'W', 'A']

* max_linesize: [1 .. 32767]

*

* Exceptions:

* INVALID_MODE, INVALID_OPERATION, INVALID_PATH, INVALID_MAXLINESIZE

*/

Datum

utl_file_fopen(PG_FUNCTION_ARGS)

{

text *open_mode;

int max_linesize;

int encoding;

const char *mode = NULL;

FILE *file;

char *fullname;

int d;

mode_t oldmask;

NOT_NULL_ARG(0);

NOT_NULL_ARG(1);

NOT_NULL_ARG(2);

NOT_NULL_ARG(3);

open_mode = PG_GETARG_TEXT_P(2);

NON_EMPTY_TEXT(open_mode);

max_linesize = PG_GETARG_INT32(3);

CHECK_LINESIZE(max_linesize);

if (PG_NARGS() > 4 && !PG_ARGISNULL(4))

{

const char *encname = NameStr(*PG_GETARG_NAME(4));

encoding = pg_char_to_encoding(encname);

if (encoding < 0)

ereport(ERROR,

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("invalid encoding name \"%s\"", encname)));

}

else

encoding = GetDatabaseEncoding();

if (VARSIZE(open_mode) - VARHDRSZ != 1)

CUSTOM_EXCEPTION(INVALID_MODE, "open mode is different than [R,W,A]");

switch (*((char *) VARDATA(open_mode)))

{

case 'a':

case 'A':

mode = "a";

break;

case 'r':

case 'R':

mode = "r";

break;

case 'w':

case 'W':

mode = "w";

break;

default:

CUSTOM_EXCEPTION(INVALID_MODE, "open mode is different than [R,W,A]");

}

/* open file */

fullname = get_safe_path(PG_GETARG_TEXT_P(0), PG_GETARG_TEXT_P(1));

/*

* We cannot use AllocateFile here because those files are automatically

* closed at the end of (sub)transactions, but we want to keep them open

* for oracle compatibility.

*/

oldmask = umask((mode_t) orafce_umask);

#ifndef WIN32

file = fopen(fullname, mode);

#else

if (pg_database_encoding_max_length() > 1)

{

wchar_t *_fullname = to_wchar(fullname);

wchar_t *_mode = to_wchar(mode);

file = _wfopen(_fullname, _mode);

pfree(_fullname);

pfree(_mode);

}

else

file = fopen(fullname, mode);

#endif

umask(oldmask);

if (!file)

IO_EXCEPTION();

d = get_descriptor(file, max_linesize, encoding);

if (d == INVALID_SLOTID)

{

fclose(file);

ereport(ERROR,

(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

errmsg("program limit exceeded"),

errdetail("Too many files opened concurrently"),

errhint("You can only open a maximum of ten files for each session")));

}

PG_RETURN_INT32(d);

}

Datum

utl_file_is_open(PG_FUNCTION_ARGS)

{

if (!PG_ARGISNULL(0))

{

int i;

int d = PG_GETARG_INT32(0);

for (i = 0; i < MAX_SLOTS; i++)

{

if (slots[i].id == d)

PG_RETURN_BOOL(slots[i].file != NULL);

}

}

PG_RETURN_BOOL(false);

}

#define CHECK_LENGTH(l) \

if (l > max_linesize) \

CUSTOM_EXCEPTION(VALUE_ERROR, "buffer is too short");

/* read line from file. set eof if is EOF */

static text *

get_line(FILE *f, size_t max_linesize, int encoding, bool *iseof)

{

int c;

char *buffer = NULL;

char *bpt;

size_t csize = 0;

text *result = NULL;

bool eof = true;

buffer = palloc(max_linesize + 2);

bpt = buffer;

errno = 0;

while (csize < max_linesize && (c = fgetc(f)) != EOF)

{

eof = false; /* I was able read one char */

if (c == '\r') /* lookin ahead \n */

{

c = fgetc(f);

if (c == EOF)

break; /* last char */

if (c != '\n')

ungetc(c, f);

/* skip \r\n */

break;

}

else if (c == '\n')

break;

++csize;

*bpt++ = c;

}

if (!eof)

{

char *decoded;

size_t len;

pg_verify_mbstr(encoding, buffer, size2int(csize), false);

decoded = (char *) pg_do_encoding_conversion((unsigned char *) buffer,

size2int(csize), encoding, GetDatabaseEncoding());

len = (decoded == buffer ? csize : strlen(decoded));

result = palloc(len + VARHDRSZ);

memcpy(VARDATA(result), decoded, len);

SET_VARSIZE(result, len + VARHDRSZ);

if (decoded != buffer)

pfree(decoded);

*iseof = false;

}

else

{

switch (errno)

{

case 0:

break;

case EBADF:

CUSTOM_EXCEPTION(INVALID_OPERATION, "file descriptor isn't valid for reading");

break;

default:

STRERROR_EXCEPTION(READ_ERROR);

break;

}

*iseof = true;

}

pfree(buffer);

return result;

}

/*

* FUNCTION UTL_FILE.GET_LINE(file UTL_TYPE.FILE_TYPE, line int DEFAULT NULL)

* RETURNS text;

*

* Reads one line from file.

*

* Exceptions:

* NO_DATA_FOUND, INVALID_FILEHANDLE, INVALID_OPERATION, READ_ERROR

*/

Datum

utl_file_get_line(PG_FUNCTION_ARGS)

{

size_t max_linesize = 0; /* keep compiler quiet */

int encoding = 0; /* keep compiler quiet */

FILE *f;

text *result;

bool iseof;

CHECK_FILE_HANDLE();

f = get_stream(PG_GETARG_INT32(0), &max_linesize, &encoding);

/* 'len' overwrites max_linesize, but must be smaller than max_linesize */

if (PG_NARGS() > 1 && !PG_ARGISNULL(1))

{

size_t len = (size_t) PG_GETARG_INT32(1);

CHECK_LINESIZE(len);

if (max_linesize > len)

max_linesize = len;

}

result = get_line(f, max_linesize, encoding, &iseof);

if (iseof)

ereport(ERROR,

(errcode(ERRCODE_NO_DATA_FOUND),

errmsg("no data found")));

PG_RETURN_TEXT_P(result);

}

/*

* FUNCTION UTL_FILE.GET_NEXTLINE(file UTL_TYPE.FILE_TYPE)

* RETURNS text;

*

* Reads one line from file or retutns NULL

* by Steven Feuerstein.

*

* Exceptions:

* INVALID_FILEHANDLE, INVALID_OPERATION, READ_ERROR

*/

Datum

utl_file_get_nextline(PG_FUNCTION_ARGS)

{

size_t max_linesize = 0; /* keep compiler quiet */

int encoding = 0; /* keep compiler quiet */

FILE *f;

text *result;

bool iseof;

CHECK_FILE_HANDLE();

f = get_stream(PG_GETARG_INT32(0), &max_linesize, &encoding);

result = get_line(f, max_linesize, encoding, &iseof);

if (iseof)

PG_RETURN_NULL();

PG_RETURN_TEXT_P(result);

}

static void

do_flush(FILE *f)

{

if (fflush(f) != 0)

{

if (errno == EBADF)

CUSTOM_EXCEPTION(INVALID_OPERATION, "File is not an opened, or is not open for writing");

else

STRERROR_EXCEPTION(WRITE_ERROR);

}

}

/*

* FUNCTION UTL_FILE.PUT(file UTL_FILE.FILE_TYPE, buffer text)

* RETURNS bool;

*

* The PUT function puts data out to specified file. Buffer length allowed is

* 32K or 1024 (max_linesize);

*

* Exceptions:

* INVALID_FILEHANDLE, INVALID_OPERATION, WRITE_ERROR, VALUE_ERROR

*

* Note: returns bool because I cannot do envelope over void function

*/

#define CHECK_ERRNO_PUT() \

switch (errno) \

{ \

case EBADF: \

CUSTOM_EXCEPTION(INVALID_OPERATION, "file descriptor isn't valid for writing"); \

break; \

default: \

STRERROR_EXCEPTION(WRITE_ERROR); \

}

/* encode(t, encoding) */

static char *

encode_text(int encoding, text *t, size_t *length)

{

char *src = VARDATA_ANY(t);

char *encoded;

encoded = (char *) pg_do_encoding_conversion((unsigned char *) src,

VARSIZE_ANY_EXHDR(t), GetDatabaseEncoding(), encoding);

*length = (src == encoded ? VARSIZE_ANY_EXHDR(t) : strlen(encoded));

return encoded;

}

/* fwrite(encode(args[n], encoding), f) */

static size_t

do_write(PG_FUNCTION_ARGS, int n, FILE *f, size_t max_linesize, int encoding)

{

text *arg = PG_GETARG_TEXT_P(n);

char *str;

size_t len;

str = encode_text(encoding, arg, &len);

CHECK_LENGTH(len);

if (fwrite(str, 1, len, f) != len)

CHECK_ERRNO_PUT();

if (VARDATA(arg) != str)

pfree(str);

PG_FREE_IF_COPY(arg, n);

return len;

}

static FILE *

do_put(PG_FUNCTION_ARGS)

{

FILE *f;

size_t max_linesize = 0; /* keep compiler quiet */

int encoding = 0; /* keep compiler quiet */

CHECK_FILE_HANDLE();

f = get_stream(PG_GETARG_INT32(0), &max_linesize, &encoding);

NOT_NULL_ARG(1);

do_write(fcinfo, 1, f, max_linesize, encoding);

return f;

}

Datum

utl_file_put(PG_FUNCTION_ARGS)

{

do_put(fcinfo);

PG_RETURN_BOOL(true);

}

static void

do_new_line(FILE *f, int lines)

{

int i;

for (i = 0; i < lines; i++)

{

#ifndef WIN32

if (fputc('\n', f) == EOF)

CHECK_ERRNO_PUT();

#else

if (fputs("\r\n", f) == EOF)

CHECK_ERRNO_PUT();

#endif

}

}

Datum

utl_file_put_line(PG_FUNCTION_ARGS)

{

FILE *f;

bool autoflush;

f = do_put(fcinfo);

autoflush = PG_GETARG_IF_EXISTS(2, BOOL, false);

do_new_line(f, 1);

if (autoflush)

do_flush(f);

PG_RETURN_BOOL(true);

}

Datum

utl_file_new_line(PG_FUNCTION_ARGS)

{

FILE *f;

int lines;

CHECK_FILE_HANDLE();

f = get_stream(PG_GETARG_INT32(0), NULL, NULL);

lines = PG_GETARG_IF_EXISTS(1, INT32, 1);

do_new_line(f, lines);

PG_RETURN_BOOL(true);

}

/*

* FUNCTION UTL_FILE.PUTF(file UTL_FILE.FILE_TYPE,

* format text,

* arg1 text,

* arg2 text,

* arg3 text,

* arg4 text,

* arg5 text)

* RETURNS bool;

*

* Puts formated data to file. Allows %s like subst symbol.

*

* Exception:

* INVALID_FILEHANDLE, INVALID_OPERATION, WRITE_ERROR

*/

Datum

utl_file_putf(PG_FUNCTION_ARGS)

{

FILE *f;

char *format;

size_t max_linesize;

int encoding;

size_t format_length;

char *fpt;

int cur_par = 0;

size_t cur_len = 0;

CHECK_FILE_HANDLE();

f = get_stream(PG_GETARG_INT32(0), &max_linesize, &encoding);

NOT_NULL_ARG(1);

format = encode_text(encoding, PG_GETARG_TEXT_P(1), &format_length);

for (fpt = format; format_length > 0; fpt++, format_length--)

{

if (format_length == 1)

{

/* last char */

CHECK_LENGTH(++cur_len);

if (fputc(*fpt, f) == EOF)

CHECK_ERRNO_PUT();

continue;

}

/* ansi compatible string */

if (fpt[0] == '\\' && fpt[1] == 'n')

{

CHECK_LENGTH(++cur_len);

if (fputc('\n', f) == EOF)

CHECK_ERRNO_PUT();

fpt++;

format_length--;

continue;

}

if (fpt[0] == '%')

{

if (fpt[1] == '%')

{

CHECK_LENGTH(++cur_len);

if (fputc('%', f) == EOF)

CHECK_ERRNO_PUT();

}

else if (fpt[1] == 's' && ++cur_par <= 5 && !PG_ARGISNULL(cur_par + 1))

{

cur_len += do_write(fcinfo, cur_par + 1, f, max_linesize - cur_len, encoding);

}

fpt++;

format_length--;

continue;

}

CHECK_LENGTH(++cur_len);

if (fputc(fpt[0], f) == EOF)

CHECK_ERRNO_PUT();

}

PG_RETURN_BOOL(true);

}

/*

* FUNCTION UTL_FILE.FFLUSH(file UTL_FILE.FILE_TYPE)

* RETURNS void;

*

* This function makes sure that all pending data for the specified file is written

* physically out to file.

*

* Exceptions:

* INVALID_FILEHANDLE, INVALID_OPERATION, WRITE_ERROR

*/

Datum

utl_file_fflush(PG_FUNCTION_ARGS)

{

FILE *f;

CHECK_FILE_HANDLE();

f = get_stream(PG_GETARG_INT32(0), NULL, NULL);

do_flush(f);

PG_RETURN_VOID();

}

/*

* FUNCTION UTL_FILE.FCLOSE(file UTL_FILE.FILE_TYPE)

* RETURNS NULL

*

* Close an open file. This function reset file handle to NULL on Oracle platform.

* It isn't possible in PostgreSQL, and then you have to call fclose function

* like:

* file := utl_file.fclose(file);

*

* Exception:

* INVALID_FILEHANDLE, WRITE_ERROR

*/

Datum

utl_file_fclose(PG_FUNCTION_ARGS)

{

int i;

int d = PG_GETARG_INT32(0);

for (i = 0; i < MAX_SLOTS; i++)

{

if (slots[i].id == d)

{

FILE *f = slots[i].file;

slots[i].file = NULL;

slots[i].id = INVALID_SLOTID;

if (f && fclose(f) != 0)

{

if (errno == EBADF)

CUSTOM_EXCEPTION(INVALID_FILEHANDLE, "File is not an opened");

else

STRERROR_EXCEPTION(WRITE_ERROR);

}

PG_RETURN_NULL();

}

}

INVALID_FILEHANDLE_EXCEPTION();

PG_RETURN_NULL();

}

/*

* FUNCTION UTL_FILE.FCLOSE_ALL()

* RETURNS void

*

* Close all opened files.

*

* Exceptions: WRITE_ERROR

*/

Datum

utl_file_fclose_all(PG_FUNCTION_ARGS)

{

int i;

for (i = 0; i < MAX_SLOTS; i++)

{

if (slots[i].id != INVALID_SLOTID)

{

FILE *f = slots[i].file;

slots[i].file = NULL;

slots[i].id = INVALID_SLOTID;

if (f && fclose(f) != 0)

{

if (errno == EBADF)

CUSTOM_EXCEPTION(INVALID_FILEHANDLE, "File is not an opened");

else

STRERROR_EXCEPTION(WRITE_ERROR);

}

}

}

PG_RETURN_VOID();

}

/*

* utl_file_dir security .. is solved with aux. table.

*

* Raise exception if don't find string in table.

*/

static void

check_secure_locality(const char *path)

{

static SPIPlanPtr plan = NULL;

Datum values[1];

char nulls[1] = {' '};

values[0] = CStringGetTextDatum(path);

/*

* SELECT 1 FROM utl_file.utl_file_dir WHERE CASE WHEN substring(dir from

* '.$') = '/' THEN substring($1, 1, length(dir)) = dir ELSE substring($1,

* 1, length(dir) + 1) = dir || '/' END

*/

if (SPI_connect() < 0)

ereport(ERROR,

(errcode(ERRCODE_INTERNAL_ERROR),

errmsg("SPI_connect failed")));

if (!plan)

{

Oid argtypes[] = {TEXTOID};

/* Don't use LIKE not to escape '_' and '%' */

SPIPlanPtr p = SPI_prepare(

"SELECT 1 FROM utl_file.utl_file_dir"

" WHERE CASE WHEN substring(dir from '.$') = '/' THEN"

" substring($1, 1, length(dir)) = dir"

" ELSE"

" substring($1, 1, length(dir) + 1) = dir || '/'"

" END",

1, argtypes);

if (p == NULL || (plan = SPI_saveplan(p)) == NULL)

ereport(ERROR,

(errcode(ERRCODE_INTERNAL_ERROR),

errmsg("SPI_prepare_failed")));

}

if (SPI_OK_SELECT != SPI_execute_plan(plan, values, nulls, false, 1))

ereport(ERROR,

(errcode(ERRCODE_INTERNAL_ERROR),

errmsg("can't execute sql")));

if (SPI_processed == 0)

ereport(ERROR,

(errcode(ERRCODE_RAISE_EXCEPTION),

errmsg(INVALID_PATH),

errdetail("you cannot access locality"),

errhint("locality is not found in utl_file_dir table")));

SPI_finish();

}

static char *

safe_named_location(text *location)

{

static SPIPlanPtr plan = NULL;

MemoryContext old_cxt;

Datum values[1];

char nulls[1] = {' '};

char *result;

old_cxt = CurrentMemoryContext;

values[0] = PointerGetDatum(location);

if (SPI_connect() < 0)

ereport(ERROR,

(errcode(ERRCODE_INTERNAL_ERROR),

errmsg("SPI_connect failed")));

if (!plan)

{

Oid argtypes[] = {TEXTOID};