MXS-1840 Compile all routers as C++
Minimal changes, only what is needed in order to make it compile.
This commit is contained in:
Johan Wikman
445
server/modules/routing/maxinfo/maxinfo_parse.cc
Normal file
445
server/modules/routing/maxinfo/maxinfo_parse.cc
Normal file
@ -0,0 +1,445 @@
|
||||
/*
|
||||
* Copyright (c) 2016 MariaDB Corporation Ab
|
||||
*
|
||||
* Use of this software is governed by the Business Source License included
|
||||
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
|
||||
*
|
||||
* Change Date: 2020-01-01
|
||||
*
|
||||
* On the date above, in accordance with the Business Source License, use
|
||||
* of this software will be governed by version 2 or later of the General
|
||||
* Public License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file maxinfo_parse.c - Parse the limited set of SQL that the MaxScale
|
||||
* information schema can use
|
||||
*
|
||||
* @verbatim
|
||||
* Revision History
|
||||
*
|
||||
* Date Who Description
|
||||
* 16/02/15 Mark Riddoch Initial implementation
|
||||
*
|
||||
* @endverbatim
|
||||
*/
|
||||
|
||||
#include "maxinfo.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <maxscale/alloc.h>
|
||||
#include <maxscale/service.h>
|
||||
#include <maxscale/session.h>
|
||||
#include <maxscale/router.h>
|
||||
#include <maxscale/modinfo.h>
|
||||
#include <maxscale/modutil.h>
|
||||
#include <maxscale/atomic.h>
|
||||
#include <maxscale/spinlock.h>
|
||||
#include <maxscale/dcb.h>
|
||||
#include <maxscale/poll.h>
|
||||
#include <maxscale/log_manager.h>
|
||||
|
||||
static MAXINFO_TREE *make_tree_node(MAXINFO_OPERATOR, char *, MAXINFO_TREE *, MAXINFO_TREE *);
|
||||
void maxinfo_free_tree(MAXINFO_TREE *); // This function is needed by maxinfo.c
|
||||
static char *fetch_token(char *, int *, char **);
|
||||
static MAXINFO_TREE *parse_column_list(char **sql);
|
||||
static MAXINFO_TREE *parse_table_name(char **sql);
|
||||
MAXINFO_TREE* maxinfo_parse_literals(MAXINFO_TREE *tree, int min_args, char *ptr,
|
||||
PARSE_ERROR *parse_error);
|
||||
|
||||
/**
|
||||
* Parse a SQL subset for the maxinfo plugin and return a parse tree
|
||||
*
|
||||
* @param sql The SQL query
|
||||
* @return Parse tree or NULL on error
|
||||
*/
|
||||
MAXINFO_TREE *
|
||||
maxinfo_parse(char *sql, PARSE_ERROR *parse_error)
|
||||
{
|
||||
int token;
|
||||
char *ptr, *text;
|
||||
MAXINFO_TREE *tree = NULL;
|
||||
MAXINFO_TREE *col, *table;
|
||||
|
||||
*parse_error = PARSE_NOERROR;
|
||||
while ((ptr = fetch_token(sql, &token, &text)) != NULL)
|
||||
{
|
||||
switch (token)
|
||||
{
|
||||
case LT_SHOW:
|
||||
MXS_FREE(text); // not needed
|
||||
ptr = fetch_token(ptr, &token, &text);
|
||||
if (ptr == NULL || token != LT_STRING)
|
||||
{
|
||||
// Expected show "name"
|
||||
*parse_error = PARSE_MALFORMED_SHOW;
|
||||
return NULL;
|
||||
}
|
||||
tree = make_tree_node(MAXOP_SHOW, text, NULL, NULL);
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) == NULL)
|
||||
{
|
||||
return tree;
|
||||
}
|
||||
else if (token == LT_LIKE)
|
||||
{
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) != NULL)
|
||||
{
|
||||
tree->right = make_tree_node(MAXOP_LIKE,
|
||||
text, NULL, NULL);
|
||||
return tree;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Expected expression
|
||||
*parse_error = PARSE_EXPECTED_LIKE;
|
||||
maxinfo_free_tree(tree);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
// Malformed show
|
||||
MXS_FREE(text);
|
||||
maxinfo_free_tree(tree);
|
||||
*parse_error = PARSE_MALFORMED_SHOW;
|
||||
return NULL;
|
||||
#if 0
|
||||
case LT_SELECT:
|
||||
MXS_FREE(text); // not needed
|
||||
col = parse_column_list(&ptr);
|
||||
table = parse_table_name(&ptr);
|
||||
return make_tree_node(MAXOP_SELECT, NULL, col, table);
|
||||
#endif
|
||||
case LT_FLUSH:
|
||||
MXS_FREE(text); // not needed
|
||||
ptr = fetch_token(ptr, &token, &text);
|
||||
return make_tree_node(MAXOP_FLUSH, text, NULL, NULL);
|
||||
|
||||
case LT_SHUTDOWN:
|
||||
MXS_FREE(text);
|
||||
ptr = fetch_token(ptr, &token, &text);
|
||||
tree = make_tree_node(MAXOP_SHUTDOWN, text, NULL, NULL);
|
||||
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) == NULL)
|
||||
{
|
||||
/** Possibly SHUTDOWN MAXSCALE */
|
||||
return tree;
|
||||
}
|
||||
tree->right = make_tree_node(MAXOP_LITERAL, text, NULL, NULL);
|
||||
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) != NULL)
|
||||
{
|
||||
/** Unknown token after SHUTDOWN MONITOR|SERVICE */
|
||||
*parse_error = PARSE_SYNTAX_ERROR;
|
||||
maxinfo_free_tree(tree);
|
||||
return NULL;
|
||||
}
|
||||
return tree;
|
||||
|
||||
case LT_RESTART:
|
||||
MXS_FREE(text);
|
||||
ptr = fetch_token(ptr, &token, &text);
|
||||
tree = make_tree_node(MAXOP_RESTART, text, NULL, NULL);
|
||||
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) == NULL)
|
||||
{
|
||||
/** Missing token for RESTART MONITOR|SERVICE */
|
||||
*parse_error = PARSE_SYNTAX_ERROR;
|
||||
maxinfo_free_tree(tree);
|
||||
return NULL;
|
||||
}
|
||||
tree->right = make_tree_node(MAXOP_LITERAL, text, NULL, NULL);
|
||||
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) != NULL)
|
||||
{
|
||||
/** Unknown token after RESTART MONITOR|SERVICE */
|
||||
*parse_error = PARSE_SYNTAX_ERROR;
|
||||
MXS_FREE(text);
|
||||
maxinfo_free_tree(tree);
|
||||
return NULL;
|
||||
}
|
||||
return tree;
|
||||
|
||||
case LT_SET:
|
||||
MXS_FREE(text); // not needed
|
||||
ptr = fetch_token(ptr, &token, &text);
|
||||
tree = make_tree_node(MAXOP_SET, text, NULL, NULL);
|
||||
return maxinfo_parse_literals(tree, 2, ptr, parse_error);
|
||||
|
||||
case LT_CLEAR:
|
||||
MXS_FREE(text); // not needed
|
||||
ptr = fetch_token(ptr, &token, &text);
|
||||
tree = make_tree_node(MAXOP_CLEAR, text, NULL, NULL);
|
||||
return maxinfo_parse_literals(tree, 2, ptr, parse_error);
|
||||
break;
|
||||
default:
|
||||
*parse_error = PARSE_SYNTAX_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
*parse_error = PARSE_SYNTAX_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a column list, may be a * or a valid list of string name
|
||||
* separated by a comma
|
||||
*
|
||||
* @param sql Pointer to pointer to column list updated to point to the table name
|
||||
* @return A tree of column names
|
||||
*/
|
||||
static MAXINFO_TREE *
|
||||
parse_column_list(char **ptr)
|
||||
{
|
||||
int token, lookahead;
|
||||
char *text, *text2;
|
||||
MAXINFO_TREE *tree = NULL;
|
||||
MAXINFO_TREE *rval = NULL;
|
||||
*ptr = fetch_token(*ptr, &token, &text);
|
||||
*ptr = fetch_token(*ptr, &lookahead, &text2);
|
||||
switch (token)
|
||||
{
|
||||
case LT_STRING:
|
||||
switch (lookahead)
|
||||
{
|
||||
case LT_COMMA:
|
||||
rval = make_tree_node(MAXOP_COLUMNS, text, NULL,
|
||||
parse_column_list(ptr));
|
||||
break;
|
||||
case LT_FROM:
|
||||
rval = make_tree_node(MAXOP_COLUMNS, text, NULL,
|
||||
NULL);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case LT_STAR:
|
||||
if (lookahead != LT_FROM)
|
||||
rval = make_tree_node(MAXOP_ALL_COLUMNS, NULL, NULL,
|
||||
NULL);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
MXS_FREE(text);
|
||||
MXS_FREE(text2);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Parse a table name
|
||||
*
|
||||
* @param sql Pointer to pointer to column list updated to point to the table name
|
||||
* @return A tree of table names
|
||||
*/
|
||||
static MAXINFO_TREE *
|
||||
parse_table_name(char **ptr)
|
||||
{
|
||||
int token;
|
||||
char *text;
|
||||
MAXINFO_TREE *tree = NULL;
|
||||
|
||||
*ptr = fetch_token(*ptr, &token, &text);
|
||||
if (token == LT_STRING)
|
||||
{
|
||||
return make_tree_node(MAXOP_TABLE, text, NULL, NULL);
|
||||
}
|
||||
MXS_FREE(text);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate and populate a parse tree node
|
||||
*
|
||||
* @param op The node operator
|
||||
* @param value The node value
|
||||
* @param left The left branch of the parse tree
|
||||
* @param right The right branch of the parse tree
|
||||
* @return The new parse tree node
|
||||
*/
|
||||
static MAXINFO_TREE *
|
||||
make_tree_node(MAXINFO_OPERATOR op, char *value, MAXINFO_TREE *left, MAXINFO_TREE *right)
|
||||
{
|
||||
MAXINFO_TREE *node;
|
||||
|
||||
if ((node = (MAXINFO_TREE *)MXS_MALLOC(sizeof(MAXINFO_TREE))) == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
node->op = op;
|
||||
node->value = value;
|
||||
node->left = left;
|
||||
node->right = right;
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively free the storage associated with a parse tree
|
||||
*
|
||||
* @param tree The parse tree to free
|
||||
*/
|
||||
void
|
||||
maxinfo_free_tree(MAXINFO_TREE *tree)
|
||||
{
|
||||
if (tree->left)
|
||||
{
|
||||
maxinfo_free_tree(tree->left);
|
||||
}
|
||||
if (tree->right)
|
||||
{
|
||||
maxinfo_free_tree(tree->right);
|
||||
}
|
||||
if (tree->value)
|
||||
{
|
||||
MXS_FREE(tree->value);
|
||||
}
|
||||
MXS_FREE(tree);
|
||||
}
|
||||
|
||||
/**
|
||||
* The set of keywords known to the tokeniser
|
||||
*/
|
||||
static struct
|
||||
{
|
||||
const char *text;
|
||||
int token;
|
||||
} keywords[] =
|
||||
{
|
||||
{ "show", LT_SHOW},
|
||||
{ "select", LT_SELECT},
|
||||
{ "from", LT_FROM},
|
||||
{ "like", LT_LIKE},
|
||||
{ "=", LT_EQUAL},
|
||||
{ ",", LT_COMMA},
|
||||
{ "*", LT_STAR},
|
||||
{ "flush", LT_FLUSH},
|
||||
{ "set", LT_SET},
|
||||
{ "clear", LT_CLEAR},
|
||||
{ "shutdown", LT_SHUTDOWN},
|
||||
{ "restart", LT_RESTART},
|
||||
{ NULL, 0}
|
||||
};
|
||||
|
||||
/**
|
||||
* Limited SQL tokeniser. Understands a limited set of key words and
|
||||
* quoted strings.
|
||||
*
|
||||
* @param sql The SQL to tokenise
|
||||
* @param token The returned token
|
||||
* @param text The matching text
|
||||
* @return The next position to tokenise from
|
||||
*/
|
||||
static char *
|
||||
fetch_token(char *sql, int *token, char **text)
|
||||
{
|
||||
char *s1, *s2, quote = '\0';
|
||||
int i;
|
||||
|
||||
s1 = sql;
|
||||
while (*s1 && isspace(*s1))
|
||||
{
|
||||
s1++;
|
||||
}
|
||||
if (quote == '\0' && (*s1 == '\'' || *s1 == '\"'))
|
||||
{
|
||||
quote = *s1++;
|
||||
}
|
||||
if (*s1 == '/' && *(s1 + 1) == '*')
|
||||
{
|
||||
s1 += 2;
|
||||
// Skip the comment
|
||||
do
|
||||
{
|
||||
while (*s1 && *s1 != '*')
|
||||
{
|
||||
s1++;
|
||||
}
|
||||
}
|
||||
while (*(s1 + 1) && *(s1 + 1) != '/');
|
||||
s1 += 2;
|
||||
while (*s1 && isspace(*s1))
|
||||
{
|
||||
s1++;
|
||||
}
|
||||
if (quote == '\0' && (*s1 == '\'' || *s1 == '\"'))
|
||||
{
|
||||
quote = *s1++;
|
||||
}
|
||||
}
|
||||
s2 = s1;
|
||||
while (*s2)
|
||||
{
|
||||
if (quote == '\0' && (isspace(*s2)
|
||||
|| *s2 == ',' || *s2 == '='))
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (quote == *s2)
|
||||
{
|
||||
break;
|
||||
}
|
||||
s2++;
|
||||
}
|
||||
|
||||
if (*s1 == '@' && *(s1 + 1) == '@')
|
||||
{
|
||||
*text = strndup(s1 + 2, (s2 - s1) - 2);
|
||||
*token = LT_VARIABLE;
|
||||
return s2;
|
||||
}
|
||||
|
||||
if (s1 == s2)
|
||||
{
|
||||
*text = NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
*text = strndup(s1, s2 - s1);
|
||||
for (i = 0; keywords[i].text; i++)
|
||||
{
|
||||
if (strcasecmp(keywords[i].text, *text) == 0)
|
||||
{
|
||||
*token = keywords[i].token;
|
||||
return s2;
|
||||
}
|
||||
}
|
||||
*token = LT_STRING;
|
||||
return s2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the remaining arguments as literals.
|
||||
* @param tree Previous head of the parse tree
|
||||
* @param min_args Minimum required number of arguments
|
||||
* @param ptr Pointer to client command
|
||||
* @param parse_error Pointer to parsing error to fill
|
||||
* @return Parsed tree or NULL if parsing failed
|
||||
*/
|
||||
MAXINFO_TREE* maxinfo_parse_literals(MAXINFO_TREE *tree, int min_args, char *ptr,
|
||||
PARSE_ERROR *parse_error)
|
||||
{
|
||||
int token;
|
||||
MAXINFO_TREE* node = tree;
|
||||
char *text;
|
||||
for (int i = 0; i < min_args; i++)
|
||||
{
|
||||
if ((ptr = fetch_token(ptr, &token, &text)) == NULL ||
|
||||
(node->right = make_tree_node(MAXOP_LITERAL, text, NULL, NULL)) == NULL)
|
||||
{
|
||||
*parse_error = PARSE_SYNTAX_ERROR;
|
||||
maxinfo_free_tree(tree);
|
||||
if (ptr)
|
||||
{
|
||||
MXS_FREE(text);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
node = node->right;
|
||||
}
|
||||
|
||||
return tree;
|
||||
}
|
||||
Reference in New Issue
Block a user