database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-27 23:21:58 +03:00
Code Activity

Improving various checks by Heikki Linnakangas <heikki@enterprisedb.com>

Browse Source 
- add code to check that the query tree is well-formed. It was indeed
  possible to send malformed queries in binary mode, which produced all
  kinds of strange results.

- make the left-field a uint32. There's no reason to
  arbitrarily limit it to 16-bits, and it won't increase the disk/memory
  footprint either now that QueryOperator and QueryOperand are separate
  structs.

- add check_stack_depth() call to all recursive functions I found.
  Some of them might have a natural limit so that you can't force
  arbitrarily deep recursions, but check_stack_depth() is cheap enough
  that seems best to just stick it into anything that might be a problem.
This commit is contained in:
Teodor Sigaev
2007-09-07 15:35:11 +00:00
parent e5be89981f
commit 8983852e34
6 changed files with 116 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/backend/utils/adt/tsquery_util.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/tsquery_util.c,v 1.2 2007/09/07 15:09:56 teodor Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/tsquery_util.c,v 1.3 2007/09/07 15:35:10 teodor Exp $
*
*-------------------------------------------------------------------------
*/
@ -22,6 +22,9 @@ QT2QTN(QueryItem * in, char *operand)
{
QTNode *node = (QTNode *) palloc0(sizeof(QTNode));
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
node->valnode = in;
if (in->type == QI_OPR)
@ -53,6 +56,9 @@ QTNFree(QTNode * in)
if (!in)
return;
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
if (in->valnode->type == QI_VAL && in->word && (in->flags & QTN_WORDFREE) != 0)
pfree(in->word);
@ -79,6 +85,9 @@ QTNFree(QTNode * in)
int
QTNodeCompare(QTNode * an, QTNode * bn)
{
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
if (an->valnode->type != bn->valnode->type)
return (an->valnode->type > bn->valnode->type) ? -1 : 1;
@ -133,6 +142,9 @@ QTNSort(QTNode * in)
{
int i;
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
if (in->valnode->type != QI_OPR)
return;
@ -165,6 +177,9 @@ QTNTernary(QTNode * in)
{
int i;
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
if (in->valnode->type != QI_OPR)
return;
@ -205,6 +220,9 @@ QTNBinary(QTNode * in)
{
int i;
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
if (in->valnode->type != QI_OPR)
return;
@ -244,6 +262,9 @@ QTNBinary(QTNode * in)
static void
cntsize(QTNode * in, int *sumlen, int *nnode)
{
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
*nnode += 1;
if (in->valnode->type == QI_OPR)
{
@ -268,6 +289,9 @@ typedef struct
static void
fillQT(QTN2QTState *state, QTNode *in)
{
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
if (in->valnode->type == QI_VAL)
{
memcpy(state->curitem, in->valnode, sizeof(QueryOperand));
@ -325,7 +349,12 @@ QTN2QT(QTNode *in)
QTNode *
QTNCopy(QTNode *in)
{
QTNode *out = (QTNode *) palloc(sizeof(QTNode));
QTNode *out;
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
out = (QTNode *) palloc(sizeof(QTNode));
*out = *in;
out->valnode = (QueryItem *) palloc(sizeof(QueryItem));