PostgreSQL Source Code git master
Loading...
Searching...
No Matches
Data Structures | Macros | Functions | Variables
test_saslprep.c File Reference
#include "postgres.h"
#include "access/htup_details.h"
#include "common/saslprep.h"
#include "fmgr.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "utils/builtins.h"
Include dependency graph for test_saslprep.c:

Go to the source code of this file.

Data Structures

struct  pg_saslprep_test_context
 
struct  pg_utf8_codepoint_range
 

Macros

#define PG_UTF8_TEST_RANGES_LEN    (sizeof(pg_utf8_test_ranges) / sizeof(pg_utf8_test_ranges[0]))
 

Functions

static const char * saslprep_status_to_text (pg_saslprep_rc rc)
 
 PG_FUNCTION_INFO_V1 (test_saslprep)
 
Datum test_saslprep (PG_FUNCTION_ARGS)
 
 PG_FUNCTION_INFO_V1 (test_saslprep_ranges)
 
Datum test_saslprep_ranges (PG_FUNCTION_ARGS)
 

Variables

 PG_MODULE_MAGIC
 
static const pg_utf8_codepoint_range pg_utf8_test_ranges []
 

Macro Definition Documentation

◆ PG_UTF8_TEST_RANGES_LEN

#define PG_UTF8_TEST_RANGES_LEN    (sizeof(pg_utf8_test_ranges) / sizeof(pg_utf8_test_ranges[0]))

Definition at line 138 of file test_saslprep.c.

149{
150 FuncCallContext *funcctx;
151 pg_saslprep_test_context *ctx;
152 HeapTuple tuple;
153 Datum result;
154
155 /* First call setup */
156 if (SRF_IS_FIRSTCALL())
157 {
158 MemoryContext oldcontext;
159 TupleDesc tupdesc;
160
161 funcctx = SRF_FIRSTCALL_INIT();
162 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
163
164 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
165 elog(ERROR, "return type must be a row type");
166 funcctx->tuple_desc = tupdesc;
167
168 /* Allocate context with range setup */
169 ctx = (pg_saslprep_test_context *) palloc(sizeof(pg_saslprep_test_context));
170 ctx->current_range = 0;
171 ctx->current_codepoint = pg_utf8_test_ranges[0].start_codepoint;
172 funcctx->user_fctx = ctx;
173
174 MemoryContextSwitchTo(oldcontext);
175 }
176
177 funcctx = SRF_PERCALL_SETUP();
178 ctx = (pg_saslprep_test_context *) funcctx->user_fctx;
179
180 while (ctx->current_range < PG_UTF8_TEST_RANGES_LEN)
181 {
182 char32_t codepoint = ctx->current_codepoint;
183 unsigned char utf8_buf[5];
184 char input_str[6];
185 char *output = NULL;
186 pg_saslprep_rc rc;
187 int utf8_len;
188 const char *status;
189 bytea *input_bytea;
190 bytea *output_bytea;
191 char codepoint_str[16];
192 Datum values[4] = {0};
193 bool nulls[4] = {0};
194 const pg_utf8_codepoint_range *range =
195 &pg_utf8_test_ranges[ctx->current_range];
196
197 CHECK_FOR_INTERRUPTS();
198
199 /* Switch to next range if finished with the previous one */
200 if (ctx->current_codepoint > range->end_codepoint)
201 {
202 ctx->current_range++;
203 if (ctx->current_range < PG_UTF8_TEST_RANGES_LEN)
204 ctx->current_codepoint =
205 pg_utf8_test_ranges[ctx->current_range].start_codepoint;
206 continue;
207 }
208
209 codepoint = ctx->current_codepoint;
210
211 /* Convert code point to UTF-8 */
212 utf8_len = unicode_utf8len(codepoint);
213 if (utf8_len == 0)
214 {
215 ctx->current_codepoint++;
216 continue;
217 }
218 unicode_to_utf8(codepoint, utf8_buf);
219
220 /* Create null-terminated string */
221 memcpy(input_str, utf8_buf, utf8_len);
222 input_str[utf8_len] = '\0';
223
224 /* Test with pg_saslprep */
225 rc = pg_saslprep(input_str, &output);
226
227 /* Prepare output values */
228 memset(nulls, false, sizeof(nulls));
229
230 /* codepoint as text U+XXXX format */
231 if (codepoint <= 0xFFFF)
232 snprintf(codepoint_str, sizeof(codepoint_str), "U+%04X", codepoint);
233 else
234 snprintf(codepoint_str, sizeof(codepoint_str), "U+%06X", codepoint);
235 values[0] = CStringGetTextDatum(codepoint_str);
236
237 /* status */
238 status = saslprep_status_to_text(rc);
239 values[1] = CStringGetTextDatum(status);
240
241 /* input_bytes */
242 input_bytea = (bytea *) palloc(VARHDRSZ + utf8_len);
243 SET_VARSIZE(input_bytea, VARHDRSZ + utf8_len);
244 memcpy(VARDATA(input_bytea), utf8_buf, utf8_len);
245 values[2] = PointerGetDatum(input_bytea);
246
247 /* output_bytes */
248 if (output != NULL)
249 {
250 int output_len = strlen(output);
251
252 output_bytea = (bytea *) palloc(VARHDRSZ + output_len);
253 SET_VARSIZE(output_bytea, VARHDRSZ + output_len);
254 memcpy(VARDATA(output_bytea), output, output_len);
255 values[3] = PointerGetDatum(output_bytea);
256 pfree(output);
257 }
258 else
259 {
260 nulls[3] = true;
261 values[3] = (Datum) 0;
262 }
263
264 /* Build and return tuple */
265 tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
266 result = HeapTupleGetDatum(tuple);
267
268 /* Move to next code point */
269 ctx->current_codepoint++;
270
271 SRF_RETURN_NEXT(funcctx, result);
272 }
273
274 /* All done */
275 SRF_RETURN_DONE(funcctx);
276}
values
static Datum values[MAXATTR]
Definition bootstrap.c:188
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition builtins.h:98
VARHDRSZ
#define VARHDRSZ
Definition c.h:783
ERROR
#define ERROR
Definition elog.h:39
elog
#define elog(elevel,...)
Definition elog.h:226
get_call_result_type
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition funcapi.c:276
SRF_IS_FIRSTCALL
#define SRF_IS_FIRSTCALL()
Definition funcapi.h:304
SRF_PERCALL_SETUP
#define SRF_PERCALL_SETUP()
Definition funcapi.h:308
TYPEFUNC_COMPOSITE
@ TYPEFUNC_COMPOSITE
Definition funcapi.h:149
SRF_RETURN_NEXT
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition funcapi.h:310
SRF_FIRSTCALL_INIT
#define SRF_FIRSTCALL_INIT()
Definition funcapi.h:306
HeapTupleGetDatum
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition funcapi.h:230
SRF_RETURN_DONE
#define SRF_RETURN_DONE(_funcctx)
Definition funcapi.h:328
heap_form_tuple
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition heaptuple.c:1037
output
FILE * output
Definition pg_test_timing.c:235
pfree
void pfree(void *pointer)
Definition mcxt.c:1616
palloc
void * palloc(Size size)
Definition mcxt.c:1387
CHECK_FOR_INTERRUPTS
#define CHECK_FOR_INTERRUPTS()
Definition miscadmin.h:123
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
unicode_to_utf8
static unsigned char * unicode_to_utf8(char32_t c, unsigned char *utf8string)
Definition pg_wchar.h:575
unicode_utf8len
static int unicode_utf8len(char32_t c)
Definition pg_wchar.h:607
snprintf
#define snprintf
Definition port.h:260
PointerGetDatum
static Datum PointerGetDatum(const void *X)
Definition postgres.h:342
Datum
uint64_t Datum
Definition postgres.h:70
fb
static int fb(int x)
Definition preproc-init.c:92
range
static struct cvec * range(struct vars *v, chr a, chr b, int cases)
Definition regc_locale.c:412
pg_saslprep
pg_saslprep_rc pg_saslprep(const char *input, char **output)
Definition saslprep.c:1047
pg_saslprep_rc
pg_saslprep_rc
Definition saslprep.h:21
pg_saslprep_test_context
Definition test_saslprep.c:110
pg_saslprep_test_context::current_range
int current_range
Definition test_saslprep.c:111
pg_saslprep_test_context::current_codepoint
char32_t current_codepoint
Definition test_saslprep.c:112
pg_utf8_codepoint_range
Definition test_saslprep.c:119
pg_utf8_codepoint_range::start_codepoint
char32_t start_codepoint
Definition test_saslprep.c:120
varlena
Definition c.h:778
saslprep_status_to_text
static const char * saslprep_status_to_text(pg_saslprep_rc rc)
Definition test_saslprep.c:27
PG_UTF8_TEST_RANGES_LEN
#define PG_UTF8_TEST_RANGES_LEN
Definition test_saslprep.c:138
pg_utf8_test_ranges
static const pg_utf8_codepoint_range pg_utf8_test_ranges[]
Definition test_saslprep.c:124
VARDATA
static char * VARDATA(const void *PTR)
Definition varatt.h:305
SET_VARSIZE
static void SET_VARSIZE(void *PTR, Size len)
Definition varatt.h:432

Function Documentation

◆ PG_FUNCTION_INFO_V1() [1/2]

PG_FUNCTION_INFO_V1 ( test_saslprep  )

◆ PG_FUNCTION_INFO_V1() [2/2]

PG_FUNCTION_INFO_V1 ( test_saslprep_ranges  )

◆ saslprep_status_to_text()

static const char * saslprep_status_to_text ( pg_saslprep_rc  rc)
static

Definition at line 27 of file test_saslprep.c.

28{
29 const char *status = "???";
30
31 switch (rc)
32 {
33 case SASLPREP_OOM:
34 status = "OOM";
35 break;
36 case SASLPREP_SUCCESS:
37 status = "SUCCESS";
38 break;
39 case SASLPREP_INVALID_UTF8:
40 status = "INVALID_UTF8";
41 break;
42 case SASLPREP_PROHIBITED:
43 status = "PROHIBITED";
44 break;
45 }
46
47 return status;
48}
SASLPREP_INVALID_UTF8
@ SASLPREP_INVALID_UTF8
Definition saslprep.h:24
SASLPREP_PROHIBITED
@ SASLPREP_PROHIBITED
Definition saslprep.h:25
SASLPREP_OOM
@ SASLPREP_OOM
Definition saslprep.h:23
SASLPREP_SUCCESS
@ SASLPREP_SUCCESS
Definition saslprep.h:22

References SASLPREP_INVALID_UTF8, SASLPREP_OOM, SASLPREP_PROHIBITED, and SASLPREP_SUCCESS.

Referenced by test_saslprep(), and test_saslprep_ranges().

◆ test_saslprep()

Datum test_saslprep ( PG_FUNCTION_ARGS  )

Definition at line 58 of file test_saslprep.c.

59{
60 bytea *string = PG_GETARG_BYTEA_PP(0);
61 char *src;
62 Size src_len;
63 char *input_data;
64 char *result;
65 Size result_len;
66 bytea *result_bytea = NULL;
67 const char *status = NULL;
68 Datum *values;
69 bool *nulls;
70 TupleDesc tupdesc;
71 pg_saslprep_rc rc;
72
73 /* determine result type */
74 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
75 elog(ERROR, "return type must be a row type");
76
77 values = palloc0_array(Datum, tupdesc->natts);
78 nulls = palloc0_array(bool, tupdesc->natts);
79
80 src_len = VARSIZE_ANY_EXHDR(string);
81 src = VARDATA_ANY(string);
82
83 /*
84 * Copy the input given, to make SASLprep() act on a sanitized string.
85 */
86 input_data = palloc0(src_len + 1);
87 strlcpy(input_data, src, src_len + 1);
88
89 rc = pg_saslprep(input_data, &result);
90 status = saslprep_status_to_text(rc);
91
92 if (result)
93 {
94 result_len = strlen(result);
95 result_bytea = palloc(result_len + VARHDRSZ);
96 SET_VARSIZE(result_bytea, result_len + VARHDRSZ);
97 memcpy(VARDATA(result_bytea), result, result_len);
98 values[0] = PointerGetDatum(result_bytea);
99 }
100 else
101 nulls[0] = true;
102
103 values[1] = CStringGetTextDatum(status);
104
105 PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
106}
Size
size_t Size
Definition c.h:691
palloc0_array
#define palloc0_array(type, count)
Definition fe_memutils.h:77
PG_GETARG_BYTEA_PP
#define PG_GETARG_BYTEA_PP(n)
Definition fmgr.h:309
PG_RETURN_DATUM
#define PG_RETURN_DATUM(x)
Definition fmgr.h:354
palloc0
void * palloc0(Size size)
Definition mcxt.c:1417
strlcpy
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition strlcpy.c:45
VARSIZE_ANY_EXHDR
static Size VARSIZE_ANY_EXHDR(const void *PTR)
Definition varatt.h:472
VARDATA_ANY
static char * VARDATA_ANY(const void *PTR)
Definition varatt.h:486

References CStringGetTextDatum, elog, ERROR, fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), TupleDescData::natts, palloc(), palloc0(), palloc0_array, PG_GETARG_BYTEA_PP, PG_RETURN_DATUM, pg_saslprep(), PointerGetDatum(), saslprep_status_to_text(), SET_VARSIZE(), strlcpy(), TYPEFUNC_COMPOSITE, values, VARDATA(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

◆ test_saslprep_ranges()

Datum test_saslprep_ranges ( PG_FUNCTION_ARGS  )

Definition at line 149 of file test_saslprep.c.

150{
151 FuncCallContext *funcctx;
152 pg_saslprep_test_context *ctx;
153 HeapTuple tuple;
154 Datum result;
155
156 /* First call setup */
157 if (SRF_IS_FIRSTCALL())
158 {
159 MemoryContext oldcontext;
160 TupleDesc tupdesc;
161
162 funcctx = SRF_FIRSTCALL_INIT();
163 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
164
165 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
166 elog(ERROR, "return type must be a row type");
167 funcctx->tuple_desc = tupdesc;
168
169 /* Allocate context with range setup */
170 ctx = (pg_saslprep_test_context *) palloc(sizeof(pg_saslprep_test_context));
171 ctx->current_range = 0;
172 ctx->current_codepoint = pg_utf8_test_ranges[0].start_codepoint;
173 funcctx->user_fctx = ctx;
174
175 MemoryContextSwitchTo(oldcontext);
176 }
177
178 funcctx = SRF_PERCALL_SETUP();
179 ctx = (pg_saslprep_test_context *) funcctx->user_fctx;
180
181 while (ctx->current_range < PG_UTF8_TEST_RANGES_LEN)
182 {
183 char32_t codepoint = ctx->current_codepoint;
184 unsigned char utf8_buf[5];
185 char input_str[6];
186 char *output = NULL;
187 pg_saslprep_rc rc;
188 int utf8_len;
189 const char *status;
190 bytea *input_bytea;
191 bytea *output_bytea;
192 char codepoint_str[16];
193 Datum values[4] = {0};
194 bool nulls[4] = {0};
195 const pg_utf8_codepoint_range *range =
196 &pg_utf8_test_ranges[ctx->current_range];
197
198 CHECK_FOR_INTERRUPTS();
199
200 /* Switch to next range if finished with the previous one */
201 if (ctx->current_codepoint > range->end_codepoint)
202 {
203 ctx->current_range++;
204 if (ctx->current_range < PG_UTF8_TEST_RANGES_LEN)
205 ctx->current_codepoint =
206 pg_utf8_test_ranges[ctx->current_range].start_codepoint;
207 continue;
208 }
209
210 codepoint = ctx->current_codepoint;
211
212 /* Convert code point to UTF-8 */
213 utf8_len = unicode_utf8len(codepoint);
214 if (utf8_len == 0)
215 {
216 ctx->current_codepoint++;
217 continue;
218 }
219 unicode_to_utf8(codepoint, utf8_buf);
220
221 /* Create null-terminated string */
222 memcpy(input_str, utf8_buf, utf8_len);
223 input_str[utf8_len] = '\0';
224
225 /* Test with pg_saslprep */
226 rc = pg_saslprep(input_str, &output);
227
228 /* Prepare output values */
229 memset(nulls, false, sizeof(nulls));
230
231 /* codepoint as text U+XXXX format */
232 if (codepoint <= 0xFFFF)
233 snprintf(codepoint_str, sizeof(codepoint_str), "U+%04X", codepoint);
234 else
235 snprintf(codepoint_str, sizeof(codepoint_str), "U+%06X", codepoint);
236 values[0] = CStringGetTextDatum(codepoint_str);
237
238 /* status */
239 status = saslprep_status_to_text(rc);
240 values[1] = CStringGetTextDatum(status);
241
242 /* input_bytes */
243 input_bytea = (bytea *) palloc(VARHDRSZ + utf8_len);
244 SET_VARSIZE(input_bytea, VARHDRSZ + utf8_len);
245 memcpy(VARDATA(input_bytea), utf8_buf, utf8_len);
246 values[2] = PointerGetDatum(input_bytea);
247
248 /* output_bytes */
249 if (output != NULL)
250 {
251 int output_len = strlen(output);
252
253 output_bytea = (bytea *) palloc(VARHDRSZ + output_len);
254 SET_VARSIZE(output_bytea, VARHDRSZ + output_len);
255 memcpy(VARDATA(output_bytea), output, output_len);
256 values[3] = PointerGetDatum(output_bytea);
257 pfree(output);
258 }
259 else
260 {
261 nulls[3] = true;
262 values[3] = (Datum) 0;
263 }
264
265 /* Build and return tuple */
266 tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
267 result = HeapTupleGetDatum(tuple);
268
269 /* Move to next code point */
270 ctx->current_codepoint++;
271
272 SRF_RETURN_NEXT(funcctx, result);
273 }
274
275 /* All done */
276 SRF_RETURN_DONE(funcctx);
277}

References CHECK_FOR_INTERRUPTS, CStringGetTextDatum, pg_saslprep_test_context::current_codepoint, pg_saslprep_test_context::current_range, elog, ERROR, fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), MemoryContextSwitchTo(), output, palloc(), pfree(), pg_saslprep(), pg_utf8_test_ranges, PG_UTF8_TEST_RANGES_LEN, PointerGetDatum(), range(), saslprep_status_to_text(), SET_VARSIZE(), snprintf, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, pg_utf8_codepoint_range::start_codepoint, TYPEFUNC_COMPOSITE, unicode_to_utf8(), unicode_utf8len(), values, VARDATA(), and VARHDRSZ.

Variable Documentation

◆ PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 24 of file test_saslprep.c.

◆ pg_utf8_test_ranges

const pg_utf8_codepoint_range pg_utf8_test_ranges[]
static
Initial value:
= {
{0x0000, 0xD7FF},
{0xE000, 0xFFFF},
{0x10000, 0x1FFFF},
{0x20000, 0x2FFFF},
{0x30000, 0x3FFFF},
{0x40000, 0xDFFFF},
{0xE0000, 0xEFFFF},
{0xF0000, 0xFFFFF},
{0x100000, 0x10FFFF},
}

Definition at line 124 of file test_saslprep.c.

124 {
125 /* 1, 2, 3 bytes */
126 {0x0000, 0xD7FF}, /* Basic Multilingual Plane, before surrogates */
127 {0xE000, 0xFFFF}, /* Basic Multilingual Plane, after surrogates */
128 /* 4 bytes */
129 {0x10000, 0x1FFFF}, /* Supplementary Multilingual Plane */
130 {0x20000, 0x2FFFF}, /* Supplementary Ideographic Plane */
131 {0x30000, 0x3FFFF}, /* Tertiary Ideographic Plane */
132 {0x40000, 0xDFFFF}, /* Unassigned planes */
133 {0xE0000, 0xEFFFF}, /* Supplementary Special-purpose Plane */
134 {0xF0000, 0xFFFFF}, /* Private Use Area A */
135 {0x100000, 0x10FFFF}, /* Private Use Area B */
136};

Referenced by test_saslprep_ranges().