Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * fastpath.c
4 : * routines to handle function requests from the frontend
5 : *
6 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/tcop/fastpath.c
12 : *
13 : * NOTES
14 : * This cruft is the server side of PQfn.
15 : *
16 : *-------------------------------------------------------------------------
17 : */
18 : #include "postgres.h"
19 :
20 : #include "access/htup_details.h"
21 : #include "access/xact.h"
22 : #include "catalog/objectaccess.h"
23 : #include "catalog/pg_namespace.h"
24 : #include "catalog/pg_proc.h"
25 : #include "libpq/pqformat.h"
26 : #include "libpq/protocol.h"
27 : #include "mb/pg_wchar.h"
28 : #include "miscadmin.h"
29 : #include "port/pg_bswap.h"
30 : #include "tcop/fastpath.h"
31 : #include "tcop/tcopprot.h"
32 : #include "utils/acl.h"
33 : #include "utils/lsyscache.h"
34 : #include "utils/snapmgr.h"
35 : #include "utils/syscache.h"
36 :
37 :
38 : /*
39 : * Formerly, this code attempted to cache the function and type info
40 : * looked up by fetch_fp_info, but only for the duration of a single
41 : * transaction command (since in theory the info could change between
42 : * commands). This was utterly useless, because postgres.c executes
43 : * each fastpath call as a separate transaction command, and so the
44 : * cached data could never actually have been reused. If it had worked
45 : * as intended, it would have had problems anyway with dangling references
46 : * in the FmgrInfo struct. So, forget about caching and just repeat the
47 : * syscache fetches on each usage. They're not *that* expensive.
48 : */
49 : struct fp_info
50 : {
51 : Oid funcid;
52 : FmgrInfo flinfo; /* function lookup info for funcid */
53 : Oid namespace; /* other stuff from pg_proc */
54 : Oid rettype;
55 : Oid argtypes[FUNC_MAX_ARGS];
56 : char fname[NAMEDATALEN]; /* function name for logging */
57 : };
58 :
59 :
60 : static int16 parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip,
61 : FunctionCallInfo fcinfo);
62 :
63 : /* ----------------
64 : * SendFunctionResult
65 : * ----------------
66 : */
67 : static void
68 2084 : SendFunctionResult(Datum retval, bool isnull, Oid rettype, int16 format)
69 : {
70 : StringInfoData buf;
71 :
72 2084 : pq_beginmessage(&buf, PqMsg_FunctionCallResponse);
73 :
74 2084 : if (isnull)
75 : {
76 0 : pq_sendint32(&buf, -1);
77 : }
78 : else
79 : {
80 2084 : if (format == 0)
81 : {
82 : Oid typoutput;
83 : bool typisvarlena;
84 : char *outputstr;
85 :
86 0 : getTypeOutputInfo(rettype, &typoutput, &typisvarlena);
87 0 : outputstr = OidOutputFunctionCall(typoutput, retval);
88 0 : pq_sendcountedtext(&buf, outputstr, strlen(outputstr));
89 0 : pfree(outputstr);
90 : }
91 2084 : else if (format == 1)
92 : {
93 : Oid typsend;
94 : bool typisvarlena;
95 : bytea *outputbytes;
96 :
97 2084 : getTypeBinaryOutputInfo(rettype, &typsend, &typisvarlena);
98 2084 : outputbytes = OidSendFunctionCall(typsend, retval);
99 2084 : pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
100 2084 : pq_sendbytes(&buf, VARDATA(outputbytes),
101 2084 : VARSIZE(outputbytes) - VARHDRSZ);
102 2084 : pfree(outputbytes);
103 : }
104 : else
105 0 : ereport(ERROR,
106 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
107 : errmsg("unsupported format code: %d", format)));
108 : }
109 :
110 2084 : pq_endmessage(&buf);
111 2084 : }
112 :
113 : /*
114 : * fetch_fp_info
115 : *
116 : * Performs catalog lookups to load a struct fp_info 'fip' for the
117 : * function 'func_id'.
118 : */
119 : static void
120 2084 : fetch_fp_info(Oid func_id, struct fp_info *fip)
121 : {
122 : HeapTuple func_htp;
123 : Form_pg_proc pp;
124 :
125 : Assert(fip != NULL);
126 :
127 : /*
128 : * Since the validity of this structure is determined by whether the
129 : * funcid is OK, we clear the funcid here. It must not be set to the
130 : * correct value until we are about to return with a good struct fp_info,
131 : * since we can be interrupted (i.e., with an ereport(ERROR, ...)) at any
132 : * time. [No longer really an issue since we don't save the struct
133 : * fp_info across transactions anymore, but keep it anyway.]
134 : */
135 139628 : MemSet(fip, 0, sizeof(struct fp_info));
136 2084 : fip->funcid = InvalidOid;
137 :
138 2084 : func_htp = SearchSysCache1(PROCOID, ObjectIdGetDatum(func_id));
139 2084 : if (!HeapTupleIsValid(func_htp))
140 0 : ereport(ERROR,
141 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
142 : errmsg("function with OID %u does not exist", func_id)));
143 2084 : pp = (Form_pg_proc) GETSTRUCT(func_htp);
144 :
145 : /* reject pg_proc entries that are unsafe to call via fastpath */
146 2084 : if (pp->prokind != PROKIND_FUNCTION || pp->proretset)
147 0 : ereport(ERROR,
148 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
149 : errmsg("cannot call function \"%s\" via fastpath interface",
150 : NameStr(pp->proname))));
151 :
152 : /* watch out for catalog entries with more than FUNC_MAX_ARGS args */
153 2084 : if (pp->pronargs > FUNC_MAX_ARGS)
154 0 : elog(ERROR, "function %s has more than %d arguments",
155 : NameStr(pp->proname), FUNC_MAX_ARGS);
156 :
157 2084 : fip->namespace = pp->pronamespace;
158 2084 : fip->rettype = pp->prorettype;
159 2084 : memcpy(fip->argtypes, pp->proargtypes.values, pp->pronargs * sizeof(Oid));
160 2084 : strlcpy(fip->fname, NameStr(pp->proname), NAMEDATALEN);
161 :
162 2084 : ReleaseSysCache(func_htp);
163 :
164 2084 : fmgr_info(func_id, &fip->flinfo);
165 :
166 : /*
167 : * This must be last!
168 : */
169 2084 : fip->funcid = func_id;
170 2084 : }
171 :
172 :
173 : /*
174 : * HandleFunctionRequest
175 : *
176 : * Server side of PQfn (fastpath function calls from the frontend).
177 : * This corresponds to the libpq protocol symbol "F".
178 : *
179 : * INPUT:
180 : * postgres.c has already read the message body and will pass it in
181 : * msgBuf.
182 : *
183 : * Note: palloc()s done here and in the called function do not need to be
184 : * cleaned up explicitly. We are called from PostgresMain() in the
185 : * MessageContext memory context, which will be automatically reset when
186 : * control returns to PostgresMain.
187 : */
188 : void
189 2084 : HandleFunctionRequest(StringInfo msgBuf)
190 : {
191 2084 : LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
192 : Oid fid;
193 : AclResult aclresult;
194 : int16 rformat;
195 : Datum retval;
196 : struct fp_info my_fp;
197 : struct fp_info *fip;
198 : bool callit;
199 2084 : bool was_logged = false;
200 : char msec_str[32];
201 :
202 : /*
203 : * We only accept COMMIT/ABORT if we are in an aborted transaction, and
204 : * COMMIT/ABORT cannot be executed through the fastpath interface.
205 : */
206 2084 : if (IsAbortedTransactionBlockState())
207 0 : ereport(ERROR,
208 : (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
209 : errmsg("current transaction is aborted, "
210 : "commands ignored until end of transaction block")));
211 :
212 : /*
213 : * Now that we know we are in a valid transaction, set snapshot in case
214 : * needed by function itself or one of the datatype I/O routines.
215 : */
216 2084 : PushActiveSnapshot(GetTransactionSnapshot());
217 :
218 : /*
219 : * Begin parsing the buffer contents.
220 : */
221 2084 : fid = (Oid) pq_getmsgint(msgBuf, 4); /* function oid */
222 :
223 : /*
224 : * There used to be a lame attempt at caching lookup info here. Now we
225 : * just do the lookups on every call.
226 : */
227 2084 : fip = &my_fp;
228 2084 : fetch_fp_info(fid, fip);
229 :
230 : /* Log as soon as we have the function OID and name */
231 2084 : if (log_statement == LOGSTMT_ALL)
232 : {
233 1566 : ereport(LOG,
234 : (errmsg("fastpath function call: \"%s\" (OID %u)",
235 : fip->fname, fid)));
236 1566 : was_logged = true;
237 : }
238 :
239 : /*
240 : * Check permission to access and call function. Since we didn't go
241 : * through a normal name lookup, we need to check schema usage too.
242 : */
243 2084 : aclresult = object_aclcheck(NamespaceRelationId, fip->namespace, GetUserId(), ACL_USAGE);
244 2084 : if (aclresult != ACLCHECK_OK)
245 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
246 0 : get_namespace_name(fip->namespace));
247 2084 : InvokeNamespaceSearchHook(fip->namespace, true);
248 :
249 2084 : aclresult = object_aclcheck(ProcedureRelationId, fid, GetUserId(), ACL_EXECUTE);
250 2084 : if (aclresult != ACLCHECK_OK)
251 0 : aclcheck_error(aclresult, OBJECT_FUNCTION,
252 0 : get_func_name(fid));
253 2084 : InvokeFunctionExecuteHook(fid);
254 :
255 : /*
256 : * Prepare function call info block and insert arguments.
257 : *
258 : * Note: for now we pass collation = InvalidOid, so collation-sensitive
259 : * functions can't be called this way. Perhaps we should pass
260 : * DEFAULT_COLLATION_OID, instead?
261 : */
262 2084 : InitFunctionCallInfoData(*fcinfo, &fip->flinfo, 0, InvalidOid, NULL, NULL);
263 :
264 2084 : rformat = parse_fcall_arguments(msgBuf, fip, fcinfo);
265 :
266 : /* Verify we reached the end of the message where expected. */
267 2084 : pq_getmsgend(msgBuf);
268 :
269 : /*
270 : * If func is strict, must not call it for null args.
271 : */
272 2084 : callit = true;
273 2084 : if (fip->flinfo.fn_strict)
274 : {
275 : int i;
276 :
277 6046 : for (i = 0; i < fcinfo->nargs; i++)
278 : {
279 3962 : if (fcinfo->args[i].isnull)
280 : {
281 0 : callit = false;
282 0 : break;
283 : }
284 : }
285 : }
286 :
287 2084 : if (callit)
288 : {
289 : /* Okay, do it ... */
290 2084 : retval = FunctionCallInvoke(fcinfo);
291 : }
292 : else
293 : {
294 0 : fcinfo->isnull = true;
295 0 : retval = (Datum) 0;
296 : }
297 :
298 : /* ensure we do at least one CHECK_FOR_INTERRUPTS per function call */
299 2084 : CHECK_FOR_INTERRUPTS();
300 :
301 2084 : SendFunctionResult(retval, fcinfo->isnull, fip->rettype, rformat);
302 :
303 : /* We no longer need the snapshot */
304 2084 : PopActiveSnapshot();
305 :
306 : /*
307 : * Emit duration logging if appropriate.
308 : */
309 2084 : switch (check_log_duration(msec_str, was_logged))
310 : {
311 0 : case 1:
312 0 : ereport(LOG,
313 : (errmsg("duration: %s ms", msec_str)));
314 0 : break;
315 0 : case 2:
316 0 : ereport(LOG,
317 : (errmsg("duration: %s ms fastpath function call: \"%s\" (OID %u)",
318 : msec_str, fip->fname, fid)));
319 0 : break;
320 : }
321 2084 : }
322 :
323 : /*
324 : * Parse function arguments in a 3.0 protocol message
325 : *
326 : * Argument values are loaded into *fcinfo, and the desired result format
327 : * is returned.
328 : */
329 : static int16
330 2084 : parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip,
331 : FunctionCallInfo fcinfo)
332 : {
333 : int nargs;
334 : int i;
335 : int numAFormats;
336 2084 : int16 *aformats = NULL;
337 : StringInfoData abuf;
338 :
339 : /* Get the argument format codes */
340 2084 : numAFormats = pq_getmsgint(msgBuf, 2);
341 2084 : if (numAFormats > 0)
342 : {
343 2084 : aformats = (int16 *) palloc(numAFormats * sizeof(int16));
344 4168 : for (i = 0; i < numAFormats; i++)
345 2084 : aformats[i] = pq_getmsgint(msgBuf, 2);
346 : }
347 :
348 2084 : nargs = pq_getmsgint(msgBuf, 2); /* # of arguments */
349 :
350 2084 : if (fip->flinfo.fn_nargs != nargs || nargs > FUNC_MAX_ARGS)
351 0 : ereport(ERROR,
352 : (errcode(ERRCODE_PROTOCOL_VIOLATION),
353 : errmsg("function call message contains %d arguments but function requires %d",
354 : nargs, fip->flinfo.fn_nargs)));
355 :
356 2084 : fcinfo->nargs = nargs;
357 :
358 2084 : if (numAFormats > 1 && numAFormats != nargs)
359 0 : ereport(ERROR,
360 : (errcode(ERRCODE_PROTOCOL_VIOLATION),
361 : errmsg("function call message contains %d argument formats but %d arguments",
362 : numAFormats, nargs)));
363 :
364 2084 : initStringInfo(&abuf);
365 :
366 : /*
367 : * Copy supplied arguments into arg vector.
368 : */
369 6046 : for (i = 0; i < nargs; ++i)
370 : {
371 : int argsize;
372 : int16 aformat;
373 :
374 3962 : argsize = pq_getmsgint(msgBuf, 4);
375 3962 : if (argsize == -1)
376 : {
377 0 : fcinfo->args[i].isnull = true;
378 : }
379 : else
380 : {
381 3962 : fcinfo->args[i].isnull = false;
382 3962 : if (argsize < 0)
383 0 : ereport(ERROR,
384 : (errcode(ERRCODE_PROTOCOL_VIOLATION),
385 : errmsg("invalid argument size %d in function call message",
386 : argsize)));
387 :
388 : /* Reset abuf to empty, and insert raw data into it */
389 3962 : resetStringInfo(&abuf);
390 3962 : appendBinaryStringInfo(&abuf,
391 3962 : pq_getmsgbytes(msgBuf, argsize),
392 : argsize);
393 : }
394 :
395 3962 : if (numAFormats > 1)
396 0 : aformat = aformats[i];
397 3962 : else if (numAFormats > 0)
398 3962 : aformat = aformats[0];
399 : else
400 0 : aformat = 0; /* default = text */
401 :
402 3962 : if (aformat == 0)
403 : {
404 : Oid typinput;
405 : Oid typioparam;
406 : char *pstring;
407 :
408 0 : getTypeInputInfo(fip->argtypes[i], &typinput, &typioparam);
409 :
410 : /*
411 : * Since stringinfo.c keeps a trailing null in place even for
412 : * binary data, the contents of abuf are a valid C string. We
413 : * have to do encoding conversion before calling the typinput
414 : * routine, though.
415 : */
416 0 : if (argsize == -1)
417 0 : pstring = NULL;
418 : else
419 0 : pstring = pg_client_to_server(abuf.data, argsize);
420 :
421 0 : fcinfo->args[i].value = OidInputFunctionCall(typinput, pstring,
422 : typioparam, -1);
423 : /* Free result of encoding conversion, if any */
424 0 : if (pstring && pstring != abuf.data)
425 0 : pfree(pstring);
426 : }
427 3962 : else if (aformat == 1)
428 : {
429 : Oid typreceive;
430 : Oid typioparam;
431 : StringInfo bufptr;
432 :
433 : /* Call the argument type's binary input converter */
434 3962 : getTypeBinaryInputInfo(fip->argtypes[i], &typreceive, &typioparam);
435 :
436 3962 : if (argsize == -1)
437 0 : bufptr = NULL;
438 : else
439 3962 : bufptr = &abuf;
440 :
441 3962 : fcinfo->args[i].value = OidReceiveFunctionCall(typreceive, bufptr,
442 : typioparam, -1);
443 :
444 : /* Trouble if it didn't eat the whole buffer */
445 3962 : if (argsize != -1 && abuf.cursor != abuf.len)
446 0 : ereport(ERROR,
447 : (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
448 : errmsg("incorrect binary data format in function argument %d",
449 : i + 1)));
450 : }
451 : else
452 0 : ereport(ERROR,
453 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
454 : errmsg("unsupported format code: %d", aformat)));
455 : }
456 :
457 : /* Return result format code */
458 2084 : return (int16) pq_getmsgint(msgBuf, 2);
459 : }
|