将mysql版本号改为5.7.39
This commit is contained in:
parent
d23ef7e61e
commit
dd3e7a6fb9
|
@ -104,13 +104,15 @@
|
|||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<AdditionalIncludeDirectories>../include;../../../sdk/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableUAC>false</EnableUAC>
|
||||
<ModuleDefinitionFile>HGPdtToolDb.def</ModuleDefinitionFile>
|
||||
<AdditionalDependencies>libmysql.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<AdditionalLibraryDirectories>../lib/x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
|
@ -124,6 +126,7 @@
|
|||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<AdditionalIncludeDirectories>../include;../../../sdk/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
|
@ -132,6 +135,8 @@
|
|||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableUAC>false</EnableUAC>
|
||||
<ModuleDefinitionFile>HGPdtToolDb.def</ModuleDefinitionFile>
|
||||
<AdditionalLibraryDirectories>../lib/x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
|
||||
<AdditionalDependencies>libmysql.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
|
|
|
@ -151,7 +151,7 @@ HGResult HGPdtToolDbUserMgrImpl::Create(const HGChar* host, HGUShort port, const
|
|||
mysql_query(sql, "drop table pressure_inspection_test;");
|
||||
mysql_query(sql, "drop table pressure_inspection_desc;");
|
||||
#endif
|
||||
if (0 != CreateUserConfigTable(sql, user) && 0 != CreateMainTestTable(sql)
|
||||
if (0 != CreateUserConfigTable(sql, user) || 0 != CreateMainTestTable(sql)
|
||||
|| 0 != CreateInitInspTestTable(sql) || 0 != CreateInitInspDescTable(sql)
|
||||
|| 0 != CreateImgInspTestTable(sql) || 0 != CreateImgInspDescTable(sql)
|
||||
|| 0 != CreatePreInspTestTable(sql) || 0 != CreatePreInspDescTable(sql))
|
||||
|
|
|
@ -88,10 +88,12 @@
|
|||
<SDLCheck>true</SDLCheck>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ConformanceMode>true</ConformanceMode>
|
||||
<AdditionalIncludeDirectories>../../../sdk/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<AdditionalDependencies>../Debug/HGPdtToolDb.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
|
@ -102,12 +104,14 @@
|
|||
<SDLCheck>true</SDLCheck>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ConformanceMode>true</ConformanceMode>
|
||||
<AdditionalIncludeDirectories>../../../sdk/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<AdditionalDependencies>../Release/HGPdtToolDb.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
|
@ -132,6 +136,7 @@
|
|||
<SDLCheck>true</SDLCheck>
|
||||
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ConformanceMode>true</ConformanceMode>
|
||||
<AdditionalIncludeDirectories>../../../sdk/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
|
|
|
@ -0,0 +1,121 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#include <string.h>
|
||||
|
||||
/*
|
||||
Data in big-endian format.
|
||||
*/
|
||||
static inline void float4store(uchar *T, float A)
|
||||
{ *(T)= ((uchar *) &A)[3];
|
||||
*((T)+1)=(char) ((uchar *) &A)[2];
|
||||
*((T)+2)=(char) ((uchar *) &A)[1];
|
||||
*((T)+3)=(char) ((uchar *) &A)[0]; }
|
||||
|
||||
static inline void float4get (float *V, const uchar *M)
|
||||
{ float def_temp;
|
||||
((uchar*) &def_temp)[0]=(M)[3];
|
||||
((uchar*) &def_temp)[1]=(M)[2];
|
||||
((uchar*) &def_temp)[2]=(M)[1];
|
||||
((uchar*) &def_temp)[3]=(M)[0];
|
||||
(*V)=def_temp; }
|
||||
|
||||
static inline void float8store(uchar *T, double V)
|
||||
{ *(T)= ((uchar *) &V)[7];
|
||||
*((T)+1)=(char) ((uchar *) &V)[6];
|
||||
*((T)+2)=(char) ((uchar *) &V)[5];
|
||||
*((T)+3)=(char) ((uchar *) &V)[4];
|
||||
*((T)+4)=(char) ((uchar *) &V)[3];
|
||||
*((T)+5)=(char) ((uchar *) &V)[2];
|
||||
*((T)+6)=(char) ((uchar *) &V)[1];
|
||||
*((T)+7)=(char) ((uchar *) &V)[0]; }
|
||||
|
||||
static inline void float8get (double *V, const uchar *M)
|
||||
{ double def_temp;
|
||||
((uchar*) &def_temp)[0]=(M)[7];
|
||||
((uchar*) &def_temp)[1]=(M)[6];
|
||||
((uchar*) &def_temp)[2]=(M)[5];
|
||||
((uchar*) &def_temp)[3]=(M)[4];
|
||||
((uchar*) &def_temp)[4]=(M)[3];
|
||||
((uchar*) &def_temp)[5]=(M)[2];
|
||||
((uchar*) &def_temp)[6]=(M)[1];
|
||||
((uchar*) &def_temp)[7]=(M)[0];
|
||||
(*V) = def_temp; }
|
||||
|
||||
static inline void ushortget(uint16 *V, const uchar *pM)
|
||||
{ *V = (uint16) (((uint16) ((uchar) (pM)[1]))+
|
||||
((uint16) ((uint16) (pM)[0]) << 8)); }
|
||||
static inline void shortget (int16 *V, const uchar *pM)
|
||||
{ *V = (short) (((short) ((uchar) (pM)[1]))+
|
||||
((short) ((short) (pM)[0]) << 8)); }
|
||||
static inline void longget (int32 *V, const uchar *pM)
|
||||
{ int32 def_temp;
|
||||
((uchar*) &def_temp)[0]=(pM)[0];
|
||||
((uchar*) &def_temp)[1]=(pM)[1];
|
||||
((uchar*) &def_temp)[2]=(pM)[2];
|
||||
((uchar*) &def_temp)[3]=(pM)[3];
|
||||
(*V)=def_temp; }
|
||||
static inline void ulongget (uint32 *V, const uchar *pM)
|
||||
{ uint32 def_temp;
|
||||
((uchar*) &def_temp)[0]=(pM)[0];
|
||||
((uchar*) &def_temp)[1]=(pM)[1];
|
||||
((uchar*) &def_temp)[2]=(pM)[2];
|
||||
((uchar*) &def_temp)[3]=(pM)[3];
|
||||
(*V)=def_temp; }
|
||||
static inline void shortstore(uchar *T, int16 A)
|
||||
{ uint def_temp=(uint) (A) ;
|
||||
*(((char*)T)+1)=(char)(def_temp);
|
||||
*(((char*)T)+0)=(char)(def_temp >> 8); }
|
||||
static inline void longstore (uchar *T, int32 A)
|
||||
{ *(((char*)T)+3)=((A));
|
||||
*(((char*)T)+2)=(((A) >> 8));
|
||||
*(((char*)T)+1)=(((A) >> 16));
|
||||
*(((char*)T)+0)=(((A) >> 24)); }
|
||||
|
||||
static inline void floatget(float *V, const uchar *M)
|
||||
{
|
||||
memcpy(V, (M), sizeof(float));
|
||||
}
|
||||
|
||||
static inline void floatstore(uchar *T, float V)
|
||||
{
|
||||
memcpy((T), (&V), sizeof(float));
|
||||
}
|
||||
|
||||
static inline void doubleget(double *V, const uchar *M)
|
||||
{
|
||||
memcpy(V, (M), sizeof(double));
|
||||
}
|
||||
|
||||
static inline void doublestore(uchar *T, double V)
|
||||
{
|
||||
memcpy((T), &V, sizeof(double));
|
||||
}
|
||||
|
||||
static inline void longlongget(longlong *V, const uchar *M)
|
||||
{
|
||||
memcpy(V, (M), sizeof(ulonglong));
|
||||
}
|
||||
static inline void longlongstore(uchar *T, longlong V)
|
||||
{
|
||||
memcpy((T), &V, sizeof(ulonglong));
|
||||
}
|
|
@ -26,7 +26,7 @@
|
|||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file field_types.h
|
||||
@file binary_log_types.h
|
||||
|
||||
@brief This file contains the field type.
|
||||
|
||||
|
@ -35,61 +35,48 @@
|
|||
definitions have to be constructed to support this.
|
||||
*/
|
||||
|
||||
#ifndef FIELD_TYPES_INCLUDED
|
||||
#define FIELD_TYPES_INCLUDED
|
||||
#ifndef BINARY_LOG_TYPES_INCLUDED
|
||||
#define BINARY_LOG_TYPES_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Constants exported from this package.
|
||||
*/
|
||||
|
||||
/**
|
||||
Column types for MySQL
|
||||
*/
|
||||
enum enum_field_types {
|
||||
MYSQL_TYPE_DECIMAL,
|
||||
MYSQL_TYPE_TINY,
|
||||
MYSQL_TYPE_SHORT,
|
||||
MYSQL_TYPE_LONG,
|
||||
MYSQL_TYPE_FLOAT,
|
||||
MYSQL_TYPE_DOUBLE,
|
||||
MYSQL_TYPE_NULL,
|
||||
MYSQL_TYPE_TIMESTAMP,
|
||||
MYSQL_TYPE_LONGLONG,
|
||||
MYSQL_TYPE_INT24,
|
||||
MYSQL_TYPE_DATE,
|
||||
MYSQL_TYPE_TIME,
|
||||
MYSQL_TYPE_DATETIME,
|
||||
MYSQL_TYPE_YEAR,
|
||||
MYSQL_TYPE_NEWDATE, /**< Internal to MySQL. Not used in protocol */
|
||||
MYSQL_TYPE_VARCHAR,
|
||||
typedef enum enum_field_types {
|
||||
MYSQL_TYPE_DECIMAL, MYSQL_TYPE_TINY,
|
||||
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
|
||||
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
|
||||
MYSQL_TYPE_NULL, MYSQL_TYPE_TIMESTAMP,
|
||||
MYSQL_TYPE_LONGLONG,MYSQL_TYPE_INT24,
|
||||
MYSQL_TYPE_DATE, MYSQL_TYPE_TIME,
|
||||
MYSQL_TYPE_DATETIME, MYSQL_TYPE_YEAR,
|
||||
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
|
||||
MYSQL_TYPE_BIT,
|
||||
MYSQL_TYPE_TIMESTAMP2,
|
||||
MYSQL_TYPE_DATETIME2, /**< Internal to MySQL. Not used in protocol */
|
||||
MYSQL_TYPE_TIME2, /**< Internal to MySQL. Not used in protocol */
|
||||
MYSQL_TYPE_TYPED_ARRAY, /**< Used for replication only */
|
||||
MYSQL_TYPE_INVALID = 243,
|
||||
MYSQL_TYPE_BOOL = 244, /**< Currently just a placeholder */
|
||||
MYSQL_TYPE_JSON = 245,
|
||||
MYSQL_TYPE_NEWDECIMAL = 246,
|
||||
MYSQL_TYPE_ENUM = 247,
|
||||
MYSQL_TYPE_SET = 248,
|
||||
MYSQL_TYPE_TINY_BLOB = 249,
|
||||
MYSQL_TYPE_MEDIUM_BLOB = 250,
|
||||
MYSQL_TYPE_LONG_BLOB = 251,
|
||||
MYSQL_TYPE_BLOB = 252,
|
||||
MYSQL_TYPE_VAR_STRING = 253,
|
||||
MYSQL_TYPE_STRING = 254,
|
||||
MYSQL_TYPE_GEOMETRY = 255
|
||||
};
|
||||
MYSQL_TYPE_DATETIME2,
|
||||
MYSQL_TYPE_TIME2,
|
||||
MYSQL_TYPE_JSON=245,
|
||||
MYSQL_TYPE_NEWDECIMAL=246,
|
||||
MYSQL_TYPE_ENUM=247,
|
||||
MYSQL_TYPE_SET=248,
|
||||
MYSQL_TYPE_TINY_BLOB=249,
|
||||
MYSQL_TYPE_MEDIUM_BLOB=250,
|
||||
MYSQL_TYPE_LONG_BLOB=251,
|
||||
MYSQL_TYPE_BLOB=252,
|
||||
MYSQL_TYPE_VAR_STRING=253,
|
||||
MYSQL_TYPE_STRING=254,
|
||||
MYSQL_TYPE_GEOMETRY=255
|
||||
} enum_field_types;
|
||||
|
||||
#define DATETIME_MAX_DECIMALS 6
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#else
|
||||
typedef enum enum_field_types enum_field_types;
|
||||
#endif /* __cplusplus */
|
||||
}
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif /* FIELD_TYPES_INCLUDED */
|
||||
#endif /* BINARY_LOG_TYPES_INCLUDED */
|
|
@ -0,0 +1,104 @@
|
|||
/* Copyright (c) 2001, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
Endianness-independent definitions for architectures other
|
||||
than the x86 architecture.
|
||||
*/
|
||||
static inline int16 sint2korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
(int16) (((int16) (A[0])) +
|
||||
((int16) (A[1]) << 8))
|
||||
;
|
||||
}
|
||||
|
||||
static inline int32 sint4korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
(int32) (((int32) (A[0])) +
|
||||
(((int32) (A[1]) << 8)) +
|
||||
(((int32) (A[2]) << 16)) +
|
||||
(((int32) (A[3]) << 24)))
|
||||
;
|
||||
}
|
||||
|
||||
static inline uint16 uint2korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
(uint16) (((uint16) (A[0])) +
|
||||
((uint16) (A[1]) << 8))
|
||||
;
|
||||
}
|
||||
|
||||
static inline uint32 uint4korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
(uint32) (((uint32) (A[0])) +
|
||||
(((uint32) (A[1])) << 8) +
|
||||
(((uint32) (A[2])) << 16) +
|
||||
(((uint32) (A[3])) << 24))
|
||||
;
|
||||
}
|
||||
|
||||
static inline ulonglong uint8korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
((ulonglong)(((uint32) (A[0])) +
|
||||
(((uint32) (A[1])) << 8) +
|
||||
(((uint32) (A[2])) << 16) +
|
||||
(((uint32) (A[3])) << 24)) +
|
||||
(((ulonglong) (((uint32) (A[4])) +
|
||||
(((uint32) (A[5])) << 8) +
|
||||
(((uint32) (A[6])) << 16) +
|
||||
(((uint32) (A[7])) << 24))) <<
|
||||
32))
|
||||
;
|
||||
}
|
||||
|
||||
static inline longlong sint8korr(const uchar *A)
|
||||
{
|
||||
return (longlong) uint8korr(A);
|
||||
}
|
||||
|
||||
static inline void int2store(uchar *T, uint16 A)
|
||||
{
|
||||
uint def_temp= A ;
|
||||
*(T)= (uchar)(def_temp);
|
||||
*(T+1)= (uchar)(def_temp >> 8);
|
||||
}
|
||||
|
||||
static inline void int4store(uchar *T, uint32 A)
|
||||
{
|
||||
*(T)= (uchar) (A);
|
||||
*(T+1)=(uchar) (A >> 8);
|
||||
*(T+2)=(uchar) (A >> 16);
|
||||
*(T+3)=(uchar) (A >> 24);
|
||||
}
|
||||
|
||||
static inline void int8store(uchar *T, ulonglong A)
|
||||
{
|
||||
uint def_temp= (uint) A,
|
||||
def_temp2= (uint) (A >> 32);
|
||||
int4store(T, def_temp);
|
||||
int4store(T+4,def_temp2);
|
||||
}
|
|
@ -0,0 +1,68 @@
|
|||
/* Copyright (c) 2001, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
Optimized functions for the x86 architecture (_WIN32 included).
|
||||
|
||||
x86 handles misaligned reads and writes just fine, so suppress
|
||||
UBSAN warnings for these functions.
|
||||
*/
|
||||
static inline int16 sint2korr(const uchar *A) SUPPRESS_UBSAN;
|
||||
static inline int16 sint2korr(const uchar *A) { return *((int16*) A); }
|
||||
|
||||
static inline int32 sint4korr(const uchar *A) SUPPRESS_UBSAN;
|
||||
static inline int32 sint4korr(const uchar *A) { return *((int32*) A); }
|
||||
|
||||
static inline uint16 uint2korr(const uchar *A) SUPPRESS_UBSAN;
|
||||
static inline uint16 uint2korr(const uchar *A) { return *((uint16*) A); }
|
||||
|
||||
static inline uint32 uint4korr(const uchar *A) SUPPRESS_UBSAN;
|
||||
static inline uint32 uint4korr(const uchar *A) { return *((uint32*) A); }
|
||||
|
||||
static inline ulonglong uint8korr(const uchar *A) SUPPRESS_UBSAN;
|
||||
static inline ulonglong uint8korr(const uchar *A) { return *((ulonglong*) A);}
|
||||
|
||||
static inline longlong sint8korr(const uchar *A) SUPPRESS_UBSAN;
|
||||
static inline longlong sint8korr(const uchar *A) { return *((longlong*) A); }
|
||||
|
||||
static inline void int2store(uchar *T, uint16 A) SUPPRESS_UBSAN;
|
||||
static inline void int2store(uchar *T, uint16 A)
|
||||
{
|
||||
*((uint16*) T)= A;
|
||||
}
|
||||
|
||||
static inline void int4store(uchar *T, uint32 A) SUPPRESS_UBSAN;
|
||||
static inline void int4store(uchar *T, uint32 A)
|
||||
{
|
||||
*((uint32*) T)= A;
|
||||
}
|
||||
|
||||
static inline void int8store(uchar *T, ulonglong A) SUPPRESS_UBSAN;
|
||||
static inline void int8store(uchar *T, ulonglong A)
|
||||
{
|
||||
*((ulonglong*) T)= A;
|
||||
}
|
|
@ -0,0 +1,144 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef DECIMAL_INCLUDED
|
||||
#define DECIMAL_INCLUDED
|
||||
|
||||
typedef enum
|
||||
{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR}
|
||||
decimal_round_mode;
|
||||
typedef int32 decimal_digit_t;
|
||||
|
||||
/**
|
||||
intg is the number of *decimal* digits (NOT number of decimal_digit_t's !)
|
||||
before the point
|
||||
frac is the number of decimal digits after the point
|
||||
len is the length of buf (length of allocated space) in decimal_digit_t's,
|
||||
not in bytes
|
||||
sign false means positive, true means negative
|
||||
buf is an array of decimal_digit_t's
|
||||
*/
|
||||
typedef struct st_decimal_t {
|
||||
int intg, frac, len;
|
||||
my_bool sign;
|
||||
decimal_digit_t *buf;
|
||||
} decimal_t;
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
int internal_str2dec(const char *from, decimal_t *to, char **end,
|
||||
my_bool fixed);
|
||||
int decimal2string(const decimal_t *from, char *to, int *to_len,
|
||||
int fixed_precision, int fixed_decimals,
|
||||
char filler);
|
||||
int decimal2ulonglong(decimal_t *from, ulonglong *to);
|
||||
int ulonglong2decimal(ulonglong from, decimal_t *to);
|
||||
int decimal2longlong(decimal_t *from, longlong *to);
|
||||
int longlong2decimal(longlong from, decimal_t *to);
|
||||
int decimal2double(const decimal_t *from, double *to);
|
||||
int double2decimal(double from, decimal_t *to);
|
||||
int decimal_actual_fraction(decimal_t *from);
|
||||
int decimal2bin(decimal_t *from, uchar *to, int precision, int scale);
|
||||
int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale);
|
||||
|
||||
/**
|
||||
Convert decimal to lldiv_t.
|
||||
The integer part is stored in to->quot.
|
||||
The fractional part is multiplied to 10^9 and stored to to->rem.
|
||||
@param from Decimal value
|
||||
@param to lldiv_t value
|
||||
@retval 0 on success
|
||||
@retval !0 in error
|
||||
*/
|
||||
int decimal2lldiv_t(const decimal_t *from, lldiv_t *to);
|
||||
|
||||
/**
|
||||
Convert doube to lldiv_t.
|
||||
The integer part is stored in to->quot.
|
||||
The fractional part is multiplied to 10^9 and stored to to->rem.
|
||||
@param from Decimal value
|
||||
@param to lldiv_t value
|
||||
@retval 0 on success
|
||||
@retval !0 in error
|
||||
*/
|
||||
|
||||
int double2lldiv_t(double from, lldiv_t *to);
|
||||
int decimal_size(int precision, int scale);
|
||||
int decimal_bin_size(int precision, int scale);
|
||||
int decimal_result_size(decimal_t *from1, decimal_t *from2, char op,
|
||||
int param);
|
||||
|
||||
int decimal_intg(const decimal_t *from);
|
||||
int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
|
||||
int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
|
||||
int decimal_cmp(const decimal_t *from1, const decimal_t *from2);
|
||||
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
|
||||
int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to,
|
||||
int scale_incr);
|
||||
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
|
||||
int decimal_round(const decimal_t *from, decimal_t *to, int new_scale,
|
||||
decimal_round_mode mode);
|
||||
int decimal_is_zero(const decimal_t *from);
|
||||
void max_decimal(int precision, int frac, decimal_t *to);
|
||||
|
||||
#define string2decimal(A,B,C) internal_str2dec((A), (B), (C), 0)
|
||||
#define string2decimal_fixed(A,B,C) internal_str2dec((A), (B), (C), 1)
|
||||
|
||||
/* set a decimal_t to zero */
|
||||
|
||||
#define decimal_make_zero(dec) do { \
|
||||
(dec)->buf[0]=0; \
|
||||
(dec)->intg=1; \
|
||||
(dec)->frac=0; \
|
||||
(dec)->sign=0; \
|
||||
} while(0)
|
||||
|
||||
/*
|
||||
returns the length of the buffer to hold string representation
|
||||
of the decimal (including decimal dot, possible sign and \0)
|
||||
*/
|
||||
|
||||
#define decimal_string_size(dec) (((dec)->intg ? (dec)->intg : 1) + \
|
||||
(dec)->frac + ((dec)->frac > 0) + 2)
|
||||
|
||||
/*
|
||||
conventions:
|
||||
|
||||
decimal_smth() == 0 -- everything's ok
|
||||
decimal_smth() <= 1 -- result is usable, but precision loss is possible
|
||||
decimal_smth() <= 2 -- result can be unusable, most significant digits
|
||||
could've been lost
|
||||
decimal_smth() > 2 -- no result was generated
|
||||
*/
|
||||
|
||||
#define E_DEC_OK 0
|
||||
#define E_DEC_TRUNCATED 1
|
||||
#define E_DEC_OVERFLOW 2
|
||||
#define E_DEC_DIV_ZERO 4
|
||||
#define E_DEC_BAD_NUM 8
|
||||
#define E_DEC_OOM 16
|
||||
|
||||
#define E_DEC_ERROR 31
|
||||
#define E_DEC_FATAL_ERROR 30
|
||||
|
||||
#endif // !MYSQL_ABI_CHECK
|
||||
|
||||
#endif
|
|
@ -14,11 +14,6 @@
|
|||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
|
@ -28,118 +23,99 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file include/errmsg.h
|
||||
/* Error messages for MySQL clients */
|
||||
/* (Error messages for the daemon are in sql/share/errmsg.txt) */
|
||||
|
||||
Error messages for MySQL clients.
|
||||
These are constant and use the CR_ prefix.
|
||||
<mysqlclient_ername.h> will contain auto-generated mappings
|
||||
containing the symbolic name and the number from this file,
|
||||
and the english error messages in libmysql/errmsg.c.
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
void init_client_errs(void);
|
||||
void finish_client_errs(void);
|
||||
extern const char *client_errors[]; /* Error messages */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
Dynamic error messages for the daemon are in share/language/errmsg.sys.
|
||||
The server equivalent to <errmsg.h> is <mysqld_error.h>.
|
||||
The server equivalent to <mysqlclient_ername.h> is <mysqld_ername.h>.
|
||||
#define CR_MIN_ERROR 2000 /* For easier client code */
|
||||
#define CR_MAX_ERROR 2999
|
||||
#if !defined(ER)
|
||||
#define ER(X) (((X) >= CR_ERROR_FIRST && (X) <= CR_ERROR_LAST)? \
|
||||
client_errors[(X)-CR_ERROR_FIRST]: \
|
||||
client_errors[CR_UNKNOWN_ERROR -CR_ERROR_FIRST])
|
||||
|
||||
Note that the auth subsystem also uses codes with a CR_ prefix.
|
||||
*/
|
||||
|
||||
void init_client_errs(void);
|
||||
void finish_client_errs(void);
|
||||
extern const char *client_errors[]; /* Error messages */
|
||||
|
||||
#define CR_MIN_ERROR 2000 /* For easier client code */
|
||||
#define CR_MAX_ERROR 2999
|
||||
#define CLIENT_ERRMAP 2 /* Errormap used by my_error() */
|
||||
#endif
|
||||
#define CLIENT_ERRMAP 2 /* Errormap used by my_error() */
|
||||
|
||||
/* Do not add error numbers before CR_ERROR_FIRST. */
|
||||
/* If necessary to add lower numbers, change CR_ERROR_FIRST accordingly. */
|
||||
#define CR_ERROR_FIRST 2000 /*Copy first error nr.*/
|
||||
#define CR_UNKNOWN_ERROR 2000
|
||||
#define CR_SOCKET_CREATE_ERROR 2001
|
||||
#define CR_CONNECTION_ERROR 2002
|
||||
#define CR_CONN_HOST_ERROR 2003
|
||||
#define CR_IPSOCK_ERROR 2004
|
||||
#define CR_UNKNOWN_HOST 2005
|
||||
#define CR_SERVER_GONE_ERROR 2006
|
||||
#define CR_VERSION_ERROR 2007
|
||||
#define CR_OUT_OF_MEMORY 2008
|
||||
#define CR_WRONG_HOST_INFO 2009
|
||||
#define CR_ERROR_FIRST 2000 /*Copy first error nr.*/
|
||||
#define CR_UNKNOWN_ERROR 2000
|
||||
#define CR_SOCKET_CREATE_ERROR 2001
|
||||
#define CR_CONNECTION_ERROR 2002
|
||||
#define CR_CONN_HOST_ERROR 2003
|
||||
#define CR_IPSOCK_ERROR 2004
|
||||
#define CR_UNKNOWN_HOST 2005
|
||||
#define CR_SERVER_GONE_ERROR 2006
|
||||
#define CR_VERSION_ERROR 2007
|
||||
#define CR_OUT_OF_MEMORY 2008
|
||||
#define CR_WRONG_HOST_INFO 2009
|
||||
#define CR_LOCALHOST_CONNECTION 2010
|
||||
#define CR_TCP_CONNECTION 2011
|
||||
#define CR_TCP_CONNECTION 2011
|
||||
#define CR_SERVER_HANDSHAKE_ERR 2012
|
||||
#define CR_SERVER_LOST 2013
|
||||
#define CR_SERVER_LOST 2013
|
||||
#define CR_COMMANDS_OUT_OF_SYNC 2014
|
||||
#define CR_NAMEDPIPE_CONNECTION 2015
|
||||
#define CR_NAMEDPIPEWAIT_ERROR 2016
|
||||
#define CR_NAMEDPIPEOPEN_ERROR 2017
|
||||
#define CR_NAMEDPIPEWAIT_ERROR 2016
|
||||
#define CR_NAMEDPIPEOPEN_ERROR 2017
|
||||
#define CR_NAMEDPIPESETSTATE_ERROR 2018
|
||||
#define CR_CANT_READ_CHARSET 2019
|
||||
#define CR_CANT_READ_CHARSET 2019
|
||||
#define CR_NET_PACKET_TOO_LARGE 2020
|
||||
#define CR_EMBEDDED_CONNECTION 2021
|
||||
#define CR_PROBE_SLAVE_STATUS 2022
|
||||
#define CR_PROBE_SLAVE_HOSTS 2023
|
||||
#define CR_PROBE_SLAVE_CONNECT 2024
|
||||
#define CR_EMBEDDED_CONNECTION 2021
|
||||
#define CR_PROBE_SLAVE_STATUS 2022
|
||||
#define CR_PROBE_SLAVE_HOSTS 2023
|
||||
#define CR_PROBE_SLAVE_CONNECT 2024
|
||||
#define CR_PROBE_MASTER_CONNECT 2025
|
||||
#define CR_SSL_CONNECTION_ERROR 2026
|
||||
#define CR_MALFORMED_PACKET 2027
|
||||
#define CR_WRONG_LICENSE 2028
|
||||
#define CR_MALFORMED_PACKET 2027
|
||||
#define CR_WRONG_LICENSE 2028
|
||||
|
||||
/* new 4.1 error codes */
|
||||
#define CR_NULL_POINTER 2029
|
||||
#define CR_NO_PREPARE_STMT 2030
|
||||
#define CR_PARAMS_NOT_BOUND 2031
|
||||
#define CR_DATA_TRUNCATED 2032
|
||||
#define CR_NULL_POINTER 2029
|
||||
#define CR_NO_PREPARE_STMT 2030
|
||||
#define CR_PARAMS_NOT_BOUND 2031
|
||||
#define CR_DATA_TRUNCATED 2032
|
||||
#define CR_NO_PARAMETERS_EXISTS 2033
|
||||
#define CR_INVALID_PARAMETER_NO 2034
|
||||
#define CR_INVALID_BUFFER_USE 2035
|
||||
#define CR_INVALID_BUFFER_USE 2035
|
||||
#define CR_UNSUPPORTED_PARAM_TYPE 2036
|
||||
|
||||
#define CR_SHARED_MEMORY_CONNECTION 2037
|
||||
#define CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR 2038
|
||||
#define CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR 2039
|
||||
#define CR_SHARED_MEMORY_CONNECTION 2037
|
||||
#define CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR 2038
|
||||
#define CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR 2039
|
||||
#define CR_SHARED_MEMORY_CONNECT_FILE_MAP_ERROR 2040
|
||||
#define CR_SHARED_MEMORY_CONNECT_MAP_ERROR 2041
|
||||
#define CR_SHARED_MEMORY_FILE_MAP_ERROR 2042
|
||||
#define CR_SHARED_MEMORY_MAP_ERROR 2043
|
||||
#define CR_SHARED_MEMORY_EVENT_ERROR 2044
|
||||
#define CR_SHARED_MEMORY_CONNECT_MAP_ERROR 2041
|
||||
#define CR_SHARED_MEMORY_FILE_MAP_ERROR 2042
|
||||
#define CR_SHARED_MEMORY_MAP_ERROR 2043
|
||||
#define CR_SHARED_MEMORY_EVENT_ERROR 2044
|
||||
#define CR_SHARED_MEMORY_CONNECT_ABANDONED_ERROR 2045
|
||||
#define CR_SHARED_MEMORY_CONNECT_SET_ERROR 2046
|
||||
#define CR_CONN_UNKNOW_PROTOCOL 2047
|
||||
#define CR_INVALID_CONN_HANDLE 2048
|
||||
#define CR_UNUSED_1 2049
|
||||
#define CR_FETCH_CANCELED 2050
|
||||
#define CR_NO_DATA 2051
|
||||
#define CR_NO_STMT_METADATA 2052
|
||||
#define CR_NO_RESULT_SET 2053
|
||||
#define CR_NOT_IMPLEMENTED 2054
|
||||
#define CR_SERVER_LOST_EXTENDED 2055
|
||||
#define CR_STMT_CLOSED 2056
|
||||
#define CR_NEW_STMT_METADATA 2057
|
||||
#define CR_ALREADY_CONNECTED 2058
|
||||
#define CR_AUTH_PLUGIN_CANNOT_LOAD 2059
|
||||
#define CR_DUPLICATE_CONNECTION_ATTR 2060
|
||||
#define CR_AUTH_PLUGIN_ERR 2061
|
||||
#define CR_INSECURE_API_ERR 2062
|
||||
#define CR_FILE_NAME_TOO_LONG 2063
|
||||
#define CR_SSL_FIPS_MODE_ERR 2064
|
||||
#define CR_DEPRECATED_COMPRESSION_NOT_SUPPORTED 2065
|
||||
#define CR_COMPRESSION_WRONGLY_CONFIGURED 2066
|
||||
#define CR_KERBEROS_USER_NOT_FOUND 2067
|
||||
#define CR_LOAD_DATA_LOCAL_INFILE_REJECTED 2068
|
||||
#define CR_LOAD_DATA_LOCAL_INFILE_REALPATH_FAIL 2069
|
||||
#define CR_DNS_SRV_LOOKUP_FAILED 2070
|
||||
#define CR_MANDATORY_TRACKER_NOT_FOUND 2071
|
||||
#define CR_INVALID_FACTOR_NO 2072
|
||||
#define CR_CANT_GET_SESSION_DATA 2073
|
||||
#define CR_ERROR_LAST /*Copy last error nr:*/ 2073
|
||||
#define CR_SHARED_MEMORY_CONNECT_SET_ERROR 2046
|
||||
#define CR_CONN_UNKNOW_PROTOCOL 2047
|
||||
#define CR_INVALID_CONN_HANDLE 2048
|
||||
#define CR_UNUSED_1 2049
|
||||
#define CR_FETCH_CANCELED 2050
|
||||
#define CR_NO_DATA 2051
|
||||
#define CR_NO_STMT_METADATA 2052
|
||||
#define CR_NO_RESULT_SET 2053
|
||||
#define CR_NOT_IMPLEMENTED 2054
|
||||
#define CR_SERVER_LOST_EXTENDED 2055
|
||||
#define CR_STMT_CLOSED 2056
|
||||
#define CR_NEW_STMT_METADATA 2057
|
||||
#define CR_ALREADY_CONNECTED 2058
|
||||
#define CR_AUTH_PLUGIN_CANNOT_LOAD 2059
|
||||
#define CR_DUPLICATE_CONNECTION_ATTR 2060
|
||||
#define CR_AUTH_PLUGIN_ERR 2061
|
||||
#define CR_INSECURE_API_ERR 2062
|
||||
#define CR_ERROR_LAST /*Copy last error nr:*/ 2062
|
||||
/* Add error numbers before CR_ERROR_LAST and change it accordingly. */
|
||||
|
||||
/* Visual Studio requires '__inline' for C code */
|
||||
static inline const char *ER_CLIENT(int client_errno) {
|
||||
if (client_errno >= CR_ERROR_FIRST && client_errno <= CR_ERROR_LAST)
|
||||
return client_errors[client_errno - CR_ERROR_FIRST];
|
||||
return client_errors[CR_UNKNOWN_ERROR - CR_ERROR_FIRST];
|
||||
}
|
||||
|
||||
#endif /* ERRMSG_INCLUDED */
|
||||
|
|
|
@ -0,0 +1,163 @@
|
|||
/* Copyright (c) 2003, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/* Key cache variable structures */
|
||||
|
||||
#ifndef _keycache_h
|
||||
#define _keycache_h
|
||||
|
||||
#include "my_sys.h" /* flush_type */
|
||||
|
||||
C_MODE_START
|
||||
|
||||
/* declare structures that is used by st_key_cache */
|
||||
|
||||
struct st_block_link;
|
||||
typedef struct st_block_link BLOCK_LINK;
|
||||
struct st_hash_link;
|
||||
typedef struct st_hash_link HASH_LINK;
|
||||
|
||||
/* Thread specific variables */
|
||||
typedef struct st_keycache_thread_var
|
||||
{
|
||||
mysql_cond_t suspend;
|
||||
struct st_keycache_thread_var *next,**prev;
|
||||
void *opt_info;
|
||||
} st_keycache_thread_var;
|
||||
|
||||
/* info about requests in a waiting queue */
|
||||
typedef struct st_keycache_wqueue
|
||||
{
|
||||
st_keycache_thread_var *last_thread; /* circular list of waiting threads */
|
||||
} KEYCACHE_WQUEUE;
|
||||
|
||||
#define CHANGED_BLOCKS_HASH 128 /* must be power of 2 */
|
||||
|
||||
/*
|
||||
The key cache structure
|
||||
It also contains read-only statistics parameters.
|
||||
*/
|
||||
|
||||
typedef struct st_key_cache
|
||||
{
|
||||
my_bool key_cache_inited;
|
||||
my_bool in_resize; /* true during resize operation */
|
||||
my_bool resize_in_flush; /* true during flush of resize operation */
|
||||
my_bool can_be_used; /* usage of cache for read/write is allowed */
|
||||
size_t key_cache_mem_size; /* specified size of the cache memory */
|
||||
uint key_cache_block_size; /* size of the page buffer of a cache block */
|
||||
ulonglong min_warm_blocks; /* min number of warm blocks; */
|
||||
ulonglong age_threshold; /* age threshold for hot blocks */
|
||||
ulonglong keycache_time; /* total number of block link operations */
|
||||
uint hash_entries; /* max number of entries in the hash table */
|
||||
int hash_links; /* max number of hash links */
|
||||
int hash_links_used; /* number of hash links currently used */
|
||||
int disk_blocks; /* max number of blocks in the cache */
|
||||
ulong blocks_used; /* maximum number of concurrently used blocks */
|
||||
ulong blocks_unused; /* number of currently unused blocks */
|
||||
ulong blocks_changed; /* number of currently dirty blocks */
|
||||
ulong warm_blocks; /* number of blocks in warm sub-chain */
|
||||
ulong cnt_for_resize_op; /* counter to block resize operation */
|
||||
long blocks_available; /* number of blocks available in the LRU chain */
|
||||
HASH_LINK **hash_root; /* arr. of entries into hash table buckets */
|
||||
HASH_LINK *hash_link_root; /* memory for hash table links */
|
||||
HASH_LINK *free_hash_list; /* list of free hash links */
|
||||
BLOCK_LINK *free_block_list; /* list of free blocks */
|
||||
BLOCK_LINK *block_root; /* memory for block links */
|
||||
uchar *block_mem; /* memory for block buffers */
|
||||
BLOCK_LINK *used_last; /* ptr to the last block of the LRU chain */
|
||||
BLOCK_LINK *used_ins; /* ptr to the insertion block in LRU chain */
|
||||
mysql_mutex_t cache_lock; /* to lock access to the cache structure */
|
||||
KEYCACHE_WQUEUE resize_queue; /* threads waiting during resize operation */
|
||||
/*
|
||||
Waiting for a zero resize count. Using a queue for symmetry though
|
||||
only one thread can wait here.
|
||||
*/
|
||||
KEYCACHE_WQUEUE waiting_for_resize_cnt;
|
||||
KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link */
|
||||
KEYCACHE_WQUEUE waiting_for_block; /* requests waiting for a free block */
|
||||
BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
|
||||
BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH]; /* hash for other file bl.*/
|
||||
|
||||
/*
|
||||
The following variables are and variables used to hold parameters for
|
||||
initializing the key cache.
|
||||
*/
|
||||
|
||||
ulonglong param_buff_size; /* size the memory allocated for the cache */
|
||||
ulonglong param_block_size; /* size of the blocks in the key cache */
|
||||
ulonglong param_division_limit; /* min. percentage of warm blocks */
|
||||
ulonglong param_age_threshold; /* determines when hot block is downgraded */
|
||||
|
||||
/* Statistics variables. These are reset in reset_key_cache_counters(). */
|
||||
ulong global_blocks_changed; /* number of currently dirty blocks */
|
||||
ulonglong global_cache_w_requests;/* number of write requests (write hits) */
|
||||
ulonglong global_cache_write; /* number of writes from cache to files */
|
||||
ulonglong global_cache_r_requests;/* number of read requests (read hits) */
|
||||
ulonglong global_cache_read; /* number of reads from files to cache */
|
||||
|
||||
int blocks; /* max number of blocks in the cache */
|
||||
my_bool in_init; /* Set to 1 in MySQL during init/resize */
|
||||
} KEY_CACHE;
|
||||
|
||||
/* The default key cache */
|
||||
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
|
||||
|
||||
extern int init_key_cache(KEY_CACHE *keycache, ulonglong key_cache_block_size,
|
||||
size_t use_mem, ulonglong division_limit,
|
||||
ulonglong age_threshold);
|
||||
extern int resize_key_cache(KEY_CACHE *keycache,
|
||||
st_keycache_thread_var *thread_var,
|
||||
ulonglong key_cache_block_size,
|
||||
size_t use_mem, ulonglong division_limit,
|
||||
ulonglong age_threshold);
|
||||
extern uchar *key_cache_read(KEY_CACHE *keycache,
|
||||
st_keycache_thread_var *thread_var,
|
||||
File file, my_off_t filepos, int level,
|
||||
uchar *buff, uint length,
|
||||
uint block_length,int return_buffer);
|
||||
extern int key_cache_insert(KEY_CACHE *keycache,
|
||||
st_keycache_thread_var *thread_var,
|
||||
File file, my_off_t filepos, int level,
|
||||
uchar *buff, uint length);
|
||||
extern int key_cache_write(KEY_CACHE *keycache,
|
||||
st_keycache_thread_var *thread_var,
|
||||
File file, my_off_t filepos, int level,
|
||||
uchar *buff, uint length,
|
||||
uint block_length,int force_write);
|
||||
extern int flush_key_blocks(KEY_CACHE *keycache,
|
||||
st_keycache_thread_var *thread_var,
|
||||
int file, enum flush_type type);
|
||||
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
|
||||
|
||||
/* Functions to handle multiple key caches */
|
||||
extern my_bool multi_keycache_init(void);
|
||||
extern void multi_keycache_free(void);
|
||||
extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length);
|
||||
extern my_bool multi_key_cache_set(const uchar *key, uint length,
|
||||
KEY_CACHE *key_cache);
|
||||
extern void multi_key_cache_change(KEY_CACHE *old_data,
|
||||
KEY_CACHE *new_data);
|
||||
extern int reset_key_cache_counters(const char *name,
|
||||
KEY_CACHE *key_cache);
|
||||
C_MODE_END
|
||||
#endif /* _keycache_h */
|
|
@ -0,0 +1,105 @@
|
|||
#ifndef LITTLE_ENDIAN_INCLUDED
|
||||
#define LITTLE_ENDIAN_INCLUDED
|
||||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
Data in little-endian format.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
static inline void float4get (float *V, const uchar *M)
|
||||
{
|
||||
memcpy(V, (M), sizeof(float));
|
||||
}
|
||||
|
||||
static inline void float4store(uchar *V, float M)
|
||||
{
|
||||
memcpy(V, (&M), sizeof(float));
|
||||
}
|
||||
|
||||
static inline void float8get (double *V, const uchar *M)
|
||||
{
|
||||
memcpy(V, M, sizeof(double));
|
||||
}
|
||||
|
||||
static inline void float8store(uchar *V, double M)
|
||||
{
|
||||
memcpy(V, &M, sizeof(double));
|
||||
}
|
||||
|
||||
static inline void floatget (float *V, const uchar *M) { float4get(V, M); }
|
||||
static inline void floatstore (uchar *V, float M) { float4store(V, M); }
|
||||
|
||||
/* Bi-endian hardware.... */
|
||||
#if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN)
|
||||
static inline void doublestore(uchar *T, double V)
|
||||
{ *(((char*)T)+0)=(char) ((uchar *) &V)[4];
|
||||
*(((char*)T)+1)=(char) ((uchar *) &V)[5];
|
||||
*(((char*)T)+2)=(char) ((uchar *) &V)[6];
|
||||
*(((char*)T)+3)=(char) ((uchar *) &V)[7];
|
||||
*(((char*)T)+4)=(char) ((uchar *) &V)[0];
|
||||
*(((char*)T)+5)=(char) ((uchar *) &V)[1];
|
||||
*(((char*)T)+6)=(char) ((uchar *) &V)[2];
|
||||
*(((char*)T)+7)=(char) ((uchar *) &V)[3]; }
|
||||
static inline void doubleget(double *V, const uchar *M)
|
||||
{ double def_temp;
|
||||
((uchar*) &def_temp)[0]=(M)[4];
|
||||
((uchar*) &def_temp)[1]=(M)[5];
|
||||
((uchar*) &def_temp)[2]=(M)[6];
|
||||
((uchar*) &def_temp)[3]=(M)[7];
|
||||
((uchar*) &def_temp)[4]=(M)[0];
|
||||
((uchar*) &def_temp)[5]=(M)[1];
|
||||
((uchar*) &def_temp)[6]=(M)[2];
|
||||
((uchar*) &def_temp)[7]=(M)[3];
|
||||
(*V) = def_temp; }
|
||||
|
||||
#else /* Bi-endian hardware.... */
|
||||
|
||||
static inline void doublestore(uchar *T, double V) { memcpy(T, &V, sizeof(double)); }
|
||||
static inline void doubleget (double *V, const uchar *M) { memcpy(V, M, sizeof(double)); }
|
||||
|
||||
#endif /* Bi-endian hardware.... */
|
||||
|
||||
static inline void ushortget(uint16 *V, const uchar *pM) { *V= uint2korr(pM); }
|
||||
static inline void shortget (int16 *V, const uchar *pM) { *V= sint2korr(pM); }
|
||||
static inline void longget (int32 *V, const uchar *pM) { *V= sint4korr(pM); }
|
||||
static inline void ulongget (uint32 *V, const uchar *pM) { *V= uint4korr(pM); }
|
||||
static inline void shortstore(uchar *T, int16 V) { int2store(T, V); }
|
||||
static inline void longstore (uchar *T, int32 V) { int4store(T, V); }
|
||||
|
||||
static inline void longlongget(longlong *V, const uchar *M)
|
||||
{
|
||||
memcpy(V, (M), sizeof(ulonglong));
|
||||
}
|
||||
static inline void longlongstore(uchar *T, longlong V)
|
||||
{
|
||||
memcpy((T), &V, sizeof(ulonglong));
|
||||
}
|
||||
|
||||
#endif /* LITTLE_ENDIAN_INCLUDED */
|
|
@ -0,0 +1,813 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
A better inplementation of the UNIX ctype(3) library.
|
||||
*/
|
||||
|
||||
#ifndef _m_ctype_h
|
||||
#define _m_ctype_h
|
||||
|
||||
#include "my_global.h" /* uint16, uchar */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define MY_CS_NAME_SIZE 32
|
||||
#define MY_CS_CTYPE_TABLE_SIZE 257
|
||||
#define MY_CS_TO_LOWER_TABLE_SIZE 256
|
||||
#define MY_CS_TO_UPPER_TABLE_SIZE 256
|
||||
#define MY_CS_SORT_ORDER_TABLE_SIZE 256
|
||||
#define MY_CS_TO_UNI_TABLE_SIZE 256
|
||||
|
||||
#define CHARSET_DIR "charsets/"
|
||||
|
||||
#define my_wc_t ulong
|
||||
|
||||
#define MY_CS_REPLACEMENT_CHARACTER 0xFFFD
|
||||
|
||||
/*
|
||||
On i386 we store Unicode->CS conversion tables for
|
||||
some character sets using Big-endian order,
|
||||
to copy two bytes at onces.
|
||||
This gives some performance improvement.
|
||||
*/
|
||||
#ifdef __i386__
|
||||
#define MB2(x) (((x) >> 8) + (((x) & 0xFF) << 8))
|
||||
#define MY_PUT_MB2(s, code) { *((uint16*)(s))= (code); }
|
||||
#else
|
||||
#define MB2(x) (x)
|
||||
#define MY_PUT_MB2(s, code) { (s)[0]= code >> 8; (s)[1]= code & 0xFF; }
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
typedef struct unicase_info_char_st
|
||||
{
|
||||
uint32 toupper;
|
||||
uint32 tolower;
|
||||
uint32 sort;
|
||||
} MY_UNICASE_CHARACTER;
|
||||
|
||||
|
||||
typedef struct unicase_info_st
|
||||
{
|
||||
my_wc_t maxchar;
|
||||
const MY_UNICASE_CHARACTER **page;
|
||||
} MY_UNICASE_INFO;
|
||||
|
||||
|
||||
extern MY_UNICASE_INFO my_unicase_default;
|
||||
extern MY_UNICASE_INFO my_unicase_turkish;
|
||||
extern MY_UNICASE_INFO my_unicase_mysql500;
|
||||
extern MY_UNICASE_INFO my_unicase_unicode520;
|
||||
|
||||
#define MY_UCA_MAX_CONTRACTION 6
|
||||
#define MY_UCA_MAX_WEIGHT_SIZE 8
|
||||
#define MY_UCA_WEIGHT_LEVELS 1
|
||||
|
||||
typedef struct my_contraction_t
|
||||
{
|
||||
my_wc_t ch[MY_UCA_MAX_CONTRACTION]; /* Character sequence */
|
||||
uint16 weight[MY_UCA_MAX_WEIGHT_SIZE];/* Its weight string, 0-terminated */
|
||||
my_bool with_context;
|
||||
} MY_CONTRACTION;
|
||||
|
||||
|
||||
|
||||
typedef struct my_contraction_list_t
|
||||
{
|
||||
size_t nitems; /* Number of items in the list */
|
||||
MY_CONTRACTION *item; /* List of contractions */
|
||||
char *flags; /* Character flags, e.g. "is contraction head") */
|
||||
} MY_CONTRACTIONS;
|
||||
|
||||
|
||||
my_bool my_uca_can_be_contraction_head(const MY_CONTRACTIONS *c, my_wc_t wc);
|
||||
my_bool my_uca_can_be_contraction_tail(const MY_CONTRACTIONS *c, my_wc_t wc);
|
||||
uint16 *my_uca_contraction2_weight(const MY_CONTRACTIONS *c,
|
||||
my_wc_t wc1, my_wc_t wc2);
|
||||
|
||||
|
||||
/* Collation weights on a single level (e.g. primary, secondary, tertiarty) */
|
||||
typedef struct my_uca_level_info_st
|
||||
{
|
||||
my_wc_t maxchar;
|
||||
uchar *lengths;
|
||||
uint16 **weights;
|
||||
MY_CONTRACTIONS contractions;
|
||||
} MY_UCA_WEIGHT_LEVEL;
|
||||
|
||||
|
||||
typedef struct uca_info_st
|
||||
{
|
||||
MY_UCA_WEIGHT_LEVEL level[MY_UCA_WEIGHT_LEVELS];
|
||||
|
||||
/* Logical positions */
|
||||
my_wc_t first_non_ignorable;
|
||||
my_wc_t last_non_ignorable;
|
||||
my_wc_t first_primary_ignorable;
|
||||
my_wc_t last_primary_ignorable;
|
||||
my_wc_t first_secondary_ignorable;
|
||||
my_wc_t last_secondary_ignorable;
|
||||
my_wc_t first_tertiary_ignorable;
|
||||
my_wc_t last_tertiary_ignorable;
|
||||
my_wc_t first_trailing;
|
||||
my_wc_t last_trailing;
|
||||
my_wc_t first_variable;
|
||||
my_wc_t last_variable;
|
||||
|
||||
} MY_UCA_INFO;
|
||||
|
||||
|
||||
|
||||
extern MY_UCA_INFO my_uca_v400;
|
||||
|
||||
|
||||
typedef struct uni_ctype_st
|
||||
{
|
||||
uchar pctype;
|
||||
uchar *ctype;
|
||||
} MY_UNI_CTYPE;
|
||||
|
||||
extern MY_UNI_CTYPE my_uni_ctype[256];
|
||||
|
||||
/* wm_wc and wc_mb return codes */
|
||||
#define MY_CS_ILSEQ 0 /* Wrong by sequence: wb_wc */
|
||||
#define MY_CS_ILUNI 0 /* Cannot encode Unicode to charset: wc_mb */
|
||||
#define MY_CS_TOOSMALL -101 /* Need at least one byte: wc_mb and mb_wc */
|
||||
#define MY_CS_TOOSMALL2 -102 /* Need at least two bytes: wc_mb and mb_wc */
|
||||
#define MY_CS_TOOSMALL3 -103 /* Need at least three bytes: wc_mb and mb_wc */
|
||||
/* These following three are currently not really used */
|
||||
#define MY_CS_TOOSMALL4 -104 /* Need at least 4 bytes: wc_mb and mb_wc */
|
||||
#define MY_CS_TOOSMALL5 -105 /* Need at least 5 bytes: wc_mb and mb_wc */
|
||||
#define MY_CS_TOOSMALL6 -106 /* Need at least 6 bytes: wc_mb and mb_wc */
|
||||
/* A helper macros for "need at least n bytes" */
|
||||
#define MY_CS_TOOSMALLN(n) (-100-(n))
|
||||
|
||||
#define MY_SEQ_INTTAIL 1
|
||||
#define MY_SEQ_SPACES 2
|
||||
|
||||
/* My charsets_list flags */
|
||||
#define MY_CS_COMPILED 1 /* compiled-in sets */
|
||||
#define MY_CS_CONFIG 2 /* sets that have a *.conf file */
|
||||
#define MY_CS_INDEX 4 /* sets listed in the Index file */
|
||||
#define MY_CS_LOADED 8 /* sets that are currently loaded */
|
||||
#define MY_CS_BINSORT 16 /* if binary sort order */
|
||||
#define MY_CS_PRIMARY 32 /* if primary collation */
|
||||
#define MY_CS_STRNXFRM 64 /* if strnxfrm is used for sort */
|
||||
#define MY_CS_UNICODE 128 /* is a charset is BMP Unicode */
|
||||
#define MY_CS_READY 256 /* if a charset is initialized */
|
||||
#define MY_CS_AVAILABLE 512 /* If either compiled-in or loaded*/
|
||||
#define MY_CS_CSSORT 1024 /* if case sensitive sort order */
|
||||
#define MY_CS_HIDDEN 2048 /* don't display in SHOW */
|
||||
#define MY_CS_PUREASCII 4096 /* if a charset is pure ascii */
|
||||
#define MY_CS_NONASCII 8192 /* if not ASCII-compatible */
|
||||
#define MY_CS_UNICODE_SUPPLEMENT 16384 /* Non-BMP Unicode characters */
|
||||
#define MY_CS_LOWER_SORT 32768 /* If use lower case as weight */
|
||||
#define MY_CHARSET_UNDEFINED 0
|
||||
|
||||
/* Character repertoire flags */
|
||||
#define MY_REPERTOIRE_ASCII 1 /* Pure ASCII U+0000..U+007F */
|
||||
#define MY_REPERTOIRE_EXTENDED 2 /* Extended characters: U+0080..U+FFFF */
|
||||
#define MY_REPERTOIRE_UNICODE30 3 /* ASCII | EXTENDED: U+0000..U+FFFF */
|
||||
|
||||
/* Flags for strxfrm */
|
||||
#define MY_STRXFRM_LEVEL1 0x00000001 /* for primary weights */
|
||||
#define MY_STRXFRM_LEVEL2 0x00000002 /* for secondary weights */
|
||||
#define MY_STRXFRM_LEVEL3 0x00000004 /* for tertiary weights */
|
||||
#define MY_STRXFRM_LEVEL4 0x00000008 /* fourth level weights */
|
||||
#define MY_STRXFRM_LEVEL5 0x00000010 /* fifth level weights */
|
||||
#define MY_STRXFRM_LEVEL6 0x00000020 /* sixth level weights */
|
||||
#define MY_STRXFRM_LEVEL_ALL 0x0000003F /* Bit OR for the above six */
|
||||
#define MY_STRXFRM_NLEVELS 6 /* Number of possible levels*/
|
||||
|
||||
#define MY_STRXFRM_PAD_WITH_SPACE 0x00000040 /* if pad result with spaces */
|
||||
#define MY_STRXFRM_PAD_TO_MAXLEN 0x00000080 /* if pad tail(for filesort) */
|
||||
|
||||
#define MY_STRXFRM_DESC_LEVEL1 0x00000100 /* if desc order for level1 */
|
||||
#define MY_STRXFRM_DESC_LEVEL2 0x00000200 /* if desc order for level2 */
|
||||
#define MY_STRXFRM_DESC_LEVEL3 0x00000300 /* if desc order for level3 */
|
||||
#define MY_STRXFRM_DESC_LEVEL4 0x00000800 /* if desc order for level4 */
|
||||
#define MY_STRXFRM_DESC_LEVEL5 0x00001000 /* if desc order for level5 */
|
||||
#define MY_STRXFRM_DESC_LEVEL6 0x00002000 /* if desc order for level6 */
|
||||
#define MY_STRXFRM_DESC_SHIFT 8
|
||||
|
||||
#define MY_STRXFRM_UNUSED_00004000 0x00004000 /* for future extensions */
|
||||
#define MY_STRXFRM_UNUSED_00008000 0x00008000 /* for future extensions */
|
||||
|
||||
#define MY_STRXFRM_REVERSE_LEVEL1 0x00010000 /* if reverse order for level1 */
|
||||
#define MY_STRXFRM_REVERSE_LEVEL2 0x00020000 /* if reverse order for level2 */
|
||||
#define MY_STRXFRM_REVERSE_LEVEL3 0x00040000 /* if reverse order for level3 */
|
||||
#define MY_STRXFRM_REVERSE_LEVEL4 0x00080000 /* if reverse order for level4 */
|
||||
#define MY_STRXFRM_REVERSE_LEVEL5 0x00100000 /* if reverse order for level5 */
|
||||
#define MY_STRXFRM_REVERSE_LEVEL6 0x00200000 /* if reverse order for level6 */
|
||||
#define MY_STRXFRM_REVERSE_SHIFT 16
|
||||
|
||||
|
||||
typedef struct my_uni_idx_st
|
||||
{
|
||||
uint16 from;
|
||||
uint16 to;
|
||||
const uchar *tab;
|
||||
} MY_UNI_IDX;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint beg;
|
||||
uint end;
|
||||
uint mb_len;
|
||||
} my_match_t;
|
||||
|
||||
struct charset_info_st;
|
||||
|
||||
typedef struct my_charset_loader_st
|
||||
{
|
||||
char error[128];
|
||||
void *(*once_alloc)(size_t);
|
||||
void *(*mem_malloc)(size_t);
|
||||
void *(*mem_realloc)(void *, size_t);
|
||||
void (*mem_free)(void *);
|
||||
void (*reporter)(enum loglevel, const char *format, ...);
|
||||
int (*add_collation)(struct charset_info_st *cs);
|
||||
} MY_CHARSET_LOADER;
|
||||
|
||||
|
||||
extern int (*my_string_stack_guard)(int);
|
||||
|
||||
/* See strings/CHARSET_INFO.txt for information about this structure */
|
||||
typedef struct my_collation_handler_st
|
||||
{
|
||||
my_bool (*init)(struct charset_info_st *, MY_CHARSET_LOADER *);
|
||||
/* Collation routines */
|
||||
int (*strnncoll)(const struct charset_info_st *,
|
||||
const uchar *, size_t, const uchar *, size_t, my_bool);
|
||||
int (*strnncollsp)(const struct charset_info_st *,
|
||||
const uchar *, size_t, const uchar *, size_t,
|
||||
my_bool diff_if_only_endspace_difference);
|
||||
size_t (*strnxfrm)(const struct charset_info_st *,
|
||||
uchar *dst, size_t dstlen, uint nweights,
|
||||
const uchar *src, size_t srclen, uint flags);
|
||||
size_t (*strnxfrmlen)(const struct charset_info_st *, size_t);
|
||||
my_bool (*like_range)(const struct charset_info_st *,
|
||||
const char *s, size_t s_length,
|
||||
pchar w_prefix, pchar w_one, pchar w_many,
|
||||
size_t res_length,
|
||||
char *min_str, char *max_str,
|
||||
size_t *min_len, size_t *max_len);
|
||||
int (*wildcmp)(const struct charset_info_st *,
|
||||
const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
int escape,int w_one, int w_many);
|
||||
|
||||
int (*strcasecmp)(const struct charset_info_st *, const char *,
|
||||
const char *);
|
||||
|
||||
uint (*instr)(const struct charset_info_st *,
|
||||
const char *b, size_t b_length,
|
||||
const char *s, size_t s_length,
|
||||
my_match_t *match, uint nmatch);
|
||||
|
||||
/* Hash calculation */
|
||||
void (*hash_sort)(const struct charset_info_st *cs, const uchar *key,
|
||||
size_t len, ulong *nr1, ulong *nr2);
|
||||
my_bool (*propagate)(const struct charset_info_st *cs, const uchar *str,
|
||||
size_t len);
|
||||
} MY_COLLATION_HANDLER;
|
||||
|
||||
extern MY_COLLATION_HANDLER my_collation_mb_bin_handler;
|
||||
extern MY_COLLATION_HANDLER my_collation_8bit_bin_handler;
|
||||
extern MY_COLLATION_HANDLER my_collation_8bit_simple_ci_handler;
|
||||
extern MY_COLLATION_HANDLER my_collation_ucs2_uca_handler;
|
||||
|
||||
/* Some typedef to make it easy for C++ to make function pointers */
|
||||
typedef int (*my_charset_conv_mb_wc)(const struct charset_info_st *,
|
||||
my_wc_t *, const uchar *, const uchar *);
|
||||
typedef int (*my_charset_conv_wc_mb)(const struct charset_info_st *, my_wc_t,
|
||||
uchar *, uchar *);
|
||||
typedef size_t (*my_charset_conv_case)(const struct charset_info_st *,
|
||||
char *, size_t, char *, size_t);
|
||||
|
||||
|
||||
/* See strings/CHARSET_INFO.txt about information on this structure */
|
||||
typedef struct my_charset_handler_st
|
||||
{
|
||||
my_bool (*init)(struct charset_info_st *, MY_CHARSET_LOADER *loader);
|
||||
/* Multibyte routines */
|
||||
uint (*ismbchar)(const struct charset_info_st *, const char *,
|
||||
const char *);
|
||||
uint (*mbcharlen)(const struct charset_info_st *, uint c);
|
||||
size_t (*numchars)(const struct charset_info_st *, const char *b,
|
||||
const char *e);
|
||||
size_t (*charpos)(const struct charset_info_st *, const char *b,
|
||||
const char *e, size_t pos);
|
||||
size_t (*well_formed_len)(const struct charset_info_st *,
|
||||
const char *b,const char *e,
|
||||
size_t nchars, int *error);
|
||||
size_t (*lengthsp)(const struct charset_info_st *, const char *ptr,
|
||||
size_t length);
|
||||
size_t (*numcells)(const struct charset_info_st *, const char *b,
|
||||
const char *e);
|
||||
|
||||
/* Unicode conversion */
|
||||
my_charset_conv_mb_wc mb_wc;
|
||||
my_charset_conv_wc_mb wc_mb;
|
||||
|
||||
/* CTYPE scanner */
|
||||
int (*ctype)(const struct charset_info_st *cs, int *ctype,
|
||||
const uchar *s, const uchar *e);
|
||||
|
||||
/* Functions for case and sort conversion */
|
||||
size_t (*caseup_str)(const struct charset_info_st *, char *);
|
||||
size_t (*casedn_str)(const struct charset_info_st *, char *);
|
||||
|
||||
my_charset_conv_case caseup;
|
||||
my_charset_conv_case casedn;
|
||||
|
||||
/* Charset dependant snprintf() */
|
||||
size_t (*snprintf)(const struct charset_info_st *, char *to, size_t n,
|
||||
const char *fmt,
|
||||
...) MY_ATTRIBUTE((format(printf, 4, 5)));
|
||||
size_t (*long10_to_str)(const struct charset_info_st *, char *to, size_t n,
|
||||
int radix, long int val);
|
||||
size_t (*longlong10_to_str)(const struct charset_info_st *, char *to,
|
||||
size_t n, int radix, longlong val);
|
||||
|
||||
void (*fill)(const struct charset_info_st *, char *to, size_t len,
|
||||
int fill);
|
||||
|
||||
/* String-to-number conversion routines */
|
||||
long (*strntol)(const struct charset_info_st *, const char *s,
|
||||
size_t l, int base, char **e, int *err);
|
||||
ulong (*strntoul)(const struct charset_info_st *, const char *s,
|
||||
size_t l, int base, char **e, int *err);
|
||||
longlong (*strntoll)(const struct charset_info_st *, const char *s,
|
||||
size_t l, int base, char **e, int *err);
|
||||
ulonglong (*strntoull)(const struct charset_info_st *, const char *s,
|
||||
size_t l, int base, char **e, int *err);
|
||||
double (*strntod)(const struct charset_info_st *, char *s,
|
||||
size_t l, char **e, int *err);
|
||||
longlong (*strtoll10)(const struct charset_info_st *cs,
|
||||
const char *nptr, char **endptr, int *error);
|
||||
ulonglong (*strntoull10rnd)(const struct charset_info_st *cs,
|
||||
const char *str, size_t length,
|
||||
int unsigned_fl,
|
||||
char **endptr, int *error);
|
||||
size_t (*scan)(const struct charset_info_st *, const char *b,
|
||||
const char *e, int sq);
|
||||
} MY_CHARSET_HANDLER;
|
||||
|
||||
extern MY_CHARSET_HANDLER my_charset_8bit_handler;
|
||||
extern MY_CHARSET_HANDLER my_charset_ascii_handler;
|
||||
extern MY_CHARSET_HANDLER my_charset_ucs2_handler;
|
||||
|
||||
|
||||
/*
|
||||
We define this CHARSET_INFO_DEFINED here to prevent a repeat of the
|
||||
typedef in hash.c, which will cause a compiler error.
|
||||
*/
|
||||
#define CHARSET_INFO_DEFINED
|
||||
|
||||
/* See strings/CHARSET_INFO.txt about information on this structure */
|
||||
typedef struct charset_info_st
|
||||
{
|
||||
uint number;
|
||||
uint primary_number;
|
||||
uint binary_number;
|
||||
uint state;
|
||||
const char *csname;
|
||||
const char *name;
|
||||
const char *comment;
|
||||
const char *tailoring;
|
||||
const uchar *ctype;
|
||||
const uchar *to_lower;
|
||||
const uchar *to_upper;
|
||||
const uchar *sort_order;
|
||||
MY_UCA_INFO *uca; /* This can be changed in apply_one_rule() */
|
||||
const uint16 *tab_to_uni;
|
||||
const MY_UNI_IDX *tab_from_uni;
|
||||
const MY_UNICASE_INFO *caseinfo;
|
||||
const struct lex_state_maps_st *state_maps; /* parser internal data */
|
||||
const uchar *ident_map; /* parser internal data */
|
||||
uint strxfrm_multiply;
|
||||
uchar caseup_multiply;
|
||||
uchar casedn_multiply;
|
||||
uint mbminlen;
|
||||
uint mbmaxlen;
|
||||
uint mbmaxlenlen;
|
||||
my_wc_t min_sort_char;
|
||||
my_wc_t max_sort_char; /* For LIKE optimization */
|
||||
uchar pad_char;
|
||||
my_bool escape_with_backslash_is_dangerous;
|
||||
uchar levels_for_compare;
|
||||
uchar levels_for_order;
|
||||
|
||||
MY_CHARSET_HANDLER *cset;
|
||||
MY_COLLATION_HANDLER *coll;
|
||||
|
||||
} CHARSET_INFO;
|
||||
#define ILLEGAL_CHARSET_INFO_NUMBER (~0U)
|
||||
|
||||
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO my_charset_bin;
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO my_charset_latin1;
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO my_charset_filename;
|
||||
|
||||
extern CHARSET_INFO my_charset_big5_chinese_ci;
|
||||
extern CHARSET_INFO my_charset_big5_bin;
|
||||
extern CHARSET_INFO my_charset_cp932_japanese_ci;
|
||||
extern CHARSET_INFO my_charset_cp932_bin;
|
||||
extern CHARSET_INFO my_charset_cp1250_czech_ci;
|
||||
extern CHARSET_INFO my_charset_eucjpms_japanese_ci;
|
||||
extern CHARSET_INFO my_charset_eucjpms_bin;
|
||||
extern CHARSET_INFO my_charset_euckr_korean_ci;
|
||||
extern CHARSET_INFO my_charset_euckr_bin;
|
||||
extern CHARSET_INFO my_charset_gb2312_chinese_ci;
|
||||
extern CHARSET_INFO my_charset_gb2312_bin;
|
||||
extern CHARSET_INFO my_charset_gbk_chinese_ci;
|
||||
extern CHARSET_INFO my_charset_gbk_bin;
|
||||
extern CHARSET_INFO my_charset_gb18030_chinese_ci;
|
||||
extern CHARSET_INFO my_charset_gb18030_bin;
|
||||
extern CHARSET_INFO my_charset_latin1_german2_ci;
|
||||
extern CHARSET_INFO my_charset_latin1_bin;
|
||||
extern CHARSET_INFO my_charset_latin2_czech_ci;
|
||||
extern CHARSET_INFO my_charset_sjis_japanese_ci;
|
||||
extern CHARSET_INFO my_charset_sjis_bin;
|
||||
extern CHARSET_INFO my_charset_tis620_thai_ci;
|
||||
extern CHARSET_INFO my_charset_tis620_bin;
|
||||
extern CHARSET_INFO my_charset_ucs2_general_ci;
|
||||
extern CHARSET_INFO my_charset_ucs2_bin;
|
||||
extern CHARSET_INFO my_charset_ucs2_unicode_ci;
|
||||
extern CHARSET_INFO my_charset_ucs2_general_mysql500_ci;
|
||||
extern CHARSET_INFO my_charset_ujis_japanese_ci;
|
||||
extern CHARSET_INFO my_charset_ujis_bin;
|
||||
extern CHARSET_INFO my_charset_utf16_bin;
|
||||
extern CHARSET_INFO my_charset_utf16_general_ci;
|
||||
extern CHARSET_INFO my_charset_utf16_unicode_ci;
|
||||
extern CHARSET_INFO my_charset_utf16le_bin;
|
||||
extern CHARSET_INFO my_charset_utf16le_general_ci;
|
||||
extern CHARSET_INFO my_charset_utf32_bin;
|
||||
extern CHARSET_INFO my_charset_utf32_general_ci;
|
||||
extern CHARSET_INFO my_charset_utf32_unicode_ci;
|
||||
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO my_charset_utf8_general_ci;
|
||||
extern CHARSET_INFO my_charset_utf8_tolower_ci;
|
||||
extern CHARSET_INFO my_charset_utf8_unicode_ci;
|
||||
extern CHARSET_INFO my_charset_utf8_bin;
|
||||
extern CHARSET_INFO my_charset_utf8_general_mysql500_ci;
|
||||
extern CHARSET_INFO my_charset_utf8mb4_bin;
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO my_charset_utf8mb4_general_ci;
|
||||
extern CHARSET_INFO my_charset_utf8mb4_unicode_ci;
|
||||
#define MY_UTF8MB3 "utf8"
|
||||
#define MY_UTF8MB4 "utf8mb4"
|
||||
|
||||
|
||||
/* declarations for simple charsets */
|
||||
extern size_t my_strnxfrm_simple(const CHARSET_INFO *,
|
||||
uchar *dst, size_t dstlen, uint nweights,
|
||||
const uchar *src, size_t srclen, uint flags);
|
||||
size_t my_strnxfrmlen_simple(const CHARSET_INFO *, size_t);
|
||||
extern int my_strnncoll_simple(const CHARSET_INFO *, const uchar *, size_t,
|
||||
const uchar *, size_t, my_bool);
|
||||
|
||||
extern int my_strnncollsp_simple(const CHARSET_INFO *, const uchar *, size_t,
|
||||
const uchar *, size_t,
|
||||
my_bool diff_if_only_endspace_difference);
|
||||
|
||||
extern void my_hash_sort_simple(const CHARSET_INFO *cs,
|
||||
const uchar *key, size_t len,
|
||||
ulong *nr1, ulong *nr2);
|
||||
|
||||
extern size_t my_lengthsp_8bit(const CHARSET_INFO *cs, const char *ptr,
|
||||
size_t length);
|
||||
|
||||
extern uint my_instr_simple(const struct charset_info_st *,
|
||||
const char *b, size_t b_length,
|
||||
const char *s, size_t s_length,
|
||||
my_match_t *match, uint nmatch);
|
||||
|
||||
|
||||
/* Functions for 8bit */
|
||||
extern size_t my_caseup_str_8bit(const CHARSET_INFO *, char *);
|
||||
extern size_t my_casedn_str_8bit(const CHARSET_INFO *, char *);
|
||||
extern size_t my_caseup_8bit(const CHARSET_INFO *, char *src, size_t srclen,
|
||||
char *dst, size_t dstlen);
|
||||
extern size_t my_casedn_8bit(const CHARSET_INFO *, char *src, size_t srclen,
|
||||
char *dst, size_t dstlen);
|
||||
|
||||
extern int my_strcasecmp_8bit(const CHARSET_INFO * cs, const char *,
|
||||
const char *);
|
||||
|
||||
int my_mb_wc_8bit(const CHARSET_INFO *cs,my_wc_t *wc, const uchar *s,
|
||||
const uchar *e);
|
||||
int my_wc_mb_8bit(const CHARSET_INFO *cs,my_wc_t wc, uchar *s, uchar *e);
|
||||
|
||||
int my_mb_ctype_8bit(const CHARSET_INFO *,int *, const uchar *,const uchar *);
|
||||
int my_mb_ctype_mb(const CHARSET_INFO *,int *, const uchar *,const uchar *);
|
||||
|
||||
size_t my_scan_8bit(const CHARSET_INFO *cs, const char *b, const char *e,
|
||||
int sq);
|
||||
|
||||
size_t my_snprintf_8bit(const struct charset_info_st *, char *to, size_t n,
|
||||
const char *fmt, ...)
|
||||
MY_ATTRIBUTE((format(printf, 4, 5)));
|
||||
|
||||
long my_strntol_8bit(const CHARSET_INFO *, const char *s, size_t l,
|
||||
int base, char **e, int *err);
|
||||
ulong my_strntoul_8bit(const CHARSET_INFO *, const char *s, size_t l,
|
||||
int base, char **e, int *err);
|
||||
longlong my_strntoll_8bit(const CHARSET_INFO *, const char *s, size_t l,
|
||||
int base, char **e, int *err);
|
||||
ulonglong my_strntoull_8bit(const CHARSET_INFO *, const char *s, size_t l,
|
||||
int base, char **e, int *err);
|
||||
double my_strntod_8bit(const CHARSET_INFO *, char *s, size_t l, char **e,
|
||||
int *err);
|
||||
size_t my_long10_to_str_8bit(const CHARSET_INFO *, char *to, size_t l,
|
||||
int radix, long int val);
|
||||
size_t my_longlong10_to_str_8bit(const CHARSET_INFO *, char *to, size_t l,
|
||||
int radix, longlong val);
|
||||
|
||||
longlong my_strtoll10_8bit(const CHARSET_INFO *cs,
|
||||
const char *nptr, char **endptr, int *error);
|
||||
longlong my_strtoll10_ucs2(const CHARSET_INFO *cs,
|
||||
const char *nptr, char **endptr, int *error);
|
||||
|
||||
ulonglong my_strntoull10rnd_8bit(const CHARSET_INFO *cs,
|
||||
const char *str, size_t length, int
|
||||
unsigned_fl, char **endptr, int *error);
|
||||
ulonglong my_strntoull10rnd_ucs2(const CHARSET_INFO *cs,
|
||||
const char *str, size_t length,
|
||||
int unsigned_fl, char **endptr, int *error);
|
||||
|
||||
void my_fill_8bit(const CHARSET_INFO *cs, char* to, size_t l, int fill);
|
||||
|
||||
/* For 8-bit character set */
|
||||
my_bool my_like_range_simple(const CHARSET_INFO *cs,
|
||||
const char *ptr, size_t ptr_length,
|
||||
pbool escape, pbool w_one, pbool w_many,
|
||||
size_t res_length,
|
||||
char *min_str, char *max_str,
|
||||
size_t *min_length, size_t *max_length);
|
||||
|
||||
/* For ASCII-based multi-byte character sets with mbminlen=1 */
|
||||
my_bool my_like_range_mb(const CHARSET_INFO *cs,
|
||||
const char *ptr, size_t ptr_length,
|
||||
pbool escape, pbool w_one, pbool w_many,
|
||||
size_t res_length,
|
||||
char *min_str, char *max_str,
|
||||
size_t *min_length, size_t *max_length);
|
||||
|
||||
/* For other character sets, with arbitrary mbminlen and mbmaxlen numbers */
|
||||
my_bool my_like_range_generic(const CHARSET_INFO *cs,
|
||||
const char *ptr, size_t ptr_length,
|
||||
pbool escape, pbool w_one, pbool w_many,
|
||||
size_t res_length,
|
||||
char *min_str, char *max_str,
|
||||
size_t *min_length, size_t *max_length);
|
||||
|
||||
int my_wildcmp_8bit(const CHARSET_INFO *,
|
||||
const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
int escape, int w_one, int w_many);
|
||||
|
||||
int my_wildcmp_bin(const CHARSET_INFO *,
|
||||
const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
int escape, int w_one, int w_many);
|
||||
|
||||
size_t my_numchars_8bit(const CHARSET_INFO *, const char *b, const char *e);
|
||||
size_t my_numcells_8bit(const CHARSET_INFO *, const char *b, const char *e);
|
||||
size_t my_charpos_8bit(const CHARSET_INFO *, const char *b, const char *e,
|
||||
size_t pos);
|
||||
size_t my_well_formed_len_8bit(const CHARSET_INFO *, const char *b,
|
||||
const char *e, size_t pos, int *error);
|
||||
uint my_mbcharlen_8bit(const CHARSET_INFO *, uint c);
|
||||
|
||||
|
||||
/* Functions for multibyte charsets */
|
||||
extern size_t my_caseup_str_mb(const CHARSET_INFO *, char *);
|
||||
extern size_t my_casedn_str_mb(const CHARSET_INFO *, char *);
|
||||
extern size_t my_caseup_mb(const CHARSET_INFO *, char *src, size_t srclen,
|
||||
char *dst, size_t dstlen);
|
||||
extern size_t my_casedn_mb(const CHARSET_INFO *, char *src, size_t srclen,
|
||||
char *dst, size_t dstlen);
|
||||
extern size_t my_caseup_mb_varlen(const CHARSET_INFO *, char *src,
|
||||
size_t srclen, char *dst, size_t dstlen);
|
||||
extern size_t my_casedn_mb_varlen(const CHARSET_INFO *, char *src,
|
||||
size_t srclen, char *dst, size_t dstlen);
|
||||
extern size_t my_caseup_ujis(const CHARSET_INFO *, char *src, size_t srclen,
|
||||
char *dst, size_t dstlen);
|
||||
extern size_t my_casedn_ujis(const CHARSET_INFO *, char *src, size_t srclen,
|
||||
char *dst, size_t dstlen);
|
||||
extern int my_strcasecmp_mb(const CHARSET_INFO * cs,const char *,
|
||||
const char *);
|
||||
|
||||
int my_wildcmp_mb(const CHARSET_INFO *,
|
||||
const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
int escape, int w_one, int w_many);
|
||||
size_t my_numchars_mb(const CHARSET_INFO *, const char *b, const char *e);
|
||||
size_t my_numcells_mb(const CHARSET_INFO *, const char *b, const char *e);
|
||||
size_t my_charpos_mb(const CHARSET_INFO *, const char *b, const char *e,
|
||||
size_t pos);
|
||||
size_t my_well_formed_len_mb(const CHARSET_INFO *, const char *b,
|
||||
const char *e, size_t pos, int *error);
|
||||
uint my_instr_mb(const struct charset_info_st *,
|
||||
const char *b, size_t b_length,
|
||||
const char *s, size_t s_length,
|
||||
my_match_t *match, uint nmatch);
|
||||
|
||||
int my_strnncoll_mb_bin(const CHARSET_INFO * cs,
|
||||
const uchar *s, size_t slen,
|
||||
const uchar *t, size_t tlen,
|
||||
my_bool t_is_prefix);
|
||||
|
||||
int my_strnncollsp_mb_bin(const CHARSET_INFO *cs,
|
||||
const uchar *a, size_t a_length,
|
||||
const uchar *b, size_t b_length,
|
||||
my_bool diff_if_only_endspace_difference);
|
||||
|
||||
int my_wildcmp_mb_bin(const CHARSET_INFO *cs,
|
||||
const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
int escape, int w_one, int w_many);
|
||||
|
||||
int my_strcasecmp_mb_bin(const CHARSET_INFO * cs MY_ATTRIBUTE((unused)),
|
||||
const char *s, const char *t);
|
||||
|
||||
void my_hash_sort_mb_bin(const CHARSET_INFO *cs MY_ATTRIBUTE((unused)),
|
||||
const uchar *key, size_t len,ulong *nr1, ulong *nr2);
|
||||
|
||||
size_t my_strnxfrm_mb(const CHARSET_INFO *,
|
||||
uchar *dst, size_t dstlen, uint nweights,
|
||||
const uchar *src, size_t srclen, uint flags);
|
||||
|
||||
size_t my_strnxfrm_unicode(const CHARSET_INFO *,
|
||||
uchar *dst, size_t dstlen, uint nweights,
|
||||
const uchar *src, size_t srclen, uint flags);
|
||||
|
||||
size_t my_strnxfrm_unicode_full_bin(const CHARSET_INFO *,
|
||||
uchar *dst, size_t dstlen, uint nweights,
|
||||
const uchar *src, size_t srclen, uint flags);
|
||||
size_t my_strnxfrmlen_unicode_full_bin(const CHARSET_INFO *, size_t);
|
||||
|
||||
int my_wildcmp_unicode(const CHARSET_INFO *cs,
|
||||
const char *str, const char *str_end,
|
||||
const char *wildstr, const char *wildend,
|
||||
int escape, int w_one, int w_many,
|
||||
const MY_UNICASE_INFO *weights);
|
||||
|
||||
extern my_bool my_parse_charset_xml(MY_CHARSET_LOADER *loader,
|
||||
const char *buf, size_t buflen);
|
||||
extern char *my_strchr(const CHARSET_INFO *cs, const char *str,
|
||||
const char *end, pchar c);
|
||||
extern size_t my_strcspn(const CHARSET_INFO *cs, const char *str,
|
||||
const char *end, const char *reject,
|
||||
size_t reject_length);
|
||||
|
||||
my_bool my_propagate_simple(const CHARSET_INFO *cs, const uchar *str,
|
||||
size_t len);
|
||||
my_bool my_propagate_complex(const CHARSET_INFO *cs, const uchar *str,
|
||||
size_t len);
|
||||
|
||||
|
||||
uint my_string_repertoire(const CHARSET_INFO *cs, const char *str, size_t len);
|
||||
my_bool my_charset_is_ascii_based(const CHARSET_INFO *cs);
|
||||
my_bool my_charset_is_8bit_pure_ascii(const CHARSET_INFO *cs);
|
||||
uint my_charset_repertoire(const CHARSET_INFO *cs);
|
||||
|
||||
|
||||
uint my_strxfrm_flag_normalize(uint flags, uint nlevels);
|
||||
void my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
|
||||
uint flags, uint level);
|
||||
size_t my_strxfrm_pad_desc_and_reverse(const CHARSET_INFO *cs,
|
||||
uchar *str, uchar *frmend, uchar *strend,
|
||||
uint nweights, uint flags, uint level);
|
||||
|
||||
my_bool my_charset_is_ascii_compatible(const CHARSET_INFO *cs);
|
||||
|
||||
const MY_CONTRACTIONS *my_charset_get_contractions(const CHARSET_INFO *cs,
|
||||
int level);
|
||||
|
||||
extern size_t my_vsnprintf_ex(const CHARSET_INFO *cs, char *to, size_t n,
|
||||
const char* fmt, va_list ap);
|
||||
|
||||
size_t my_convert(char *to, size_t to_length, const CHARSET_INFO *to_cs,
|
||||
const char *from, size_t from_length,
|
||||
const CHARSET_INFO *from_cs, uint *errors);
|
||||
|
||||
uint my_mbcharlen_ptr(const CHARSET_INFO *cs, const char *s, const char *e);
|
||||
|
||||
#define _MY_U 01 /* Upper case */
|
||||
#define _MY_L 02 /* Lower case */
|
||||
#define _MY_NMR 04 /* Numeral (digit) */
|
||||
#define _MY_SPC 010 /* Spacing character */
|
||||
#define _MY_PNT 020 /* Punctuation */
|
||||
#define _MY_CTR 040 /* Control character */
|
||||
#define _MY_B 0100 /* Blank */
|
||||
#define _MY_X 0200 /* heXadecimal digit */
|
||||
|
||||
|
||||
#define my_isascii(c) (!((c) & ~0177))
|
||||
#define my_toascii(c) ((c) & 0177)
|
||||
#define my_tocntrl(c) ((c) & 31)
|
||||
#define my_toprint(c) ((c) | 64)
|
||||
#define my_toupper(s,c) (char) ((s)->to_upper[(uchar) (c)])
|
||||
#define my_tolower(s,c) (char) ((s)->to_lower[(uchar) (c)])
|
||||
#define my_isalpha(s, c) (((s)->ctype+1)[(uchar) (c)] & (_MY_U | _MY_L))
|
||||
#define my_isupper(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_U)
|
||||
#define my_islower(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_L)
|
||||
#define my_isdigit(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_NMR)
|
||||
#define my_isxdigit(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_X)
|
||||
#define my_isalnum(s, c) (((s)->ctype+1)[(uchar) (c)] & (_MY_U | _MY_L | _MY_NMR))
|
||||
#define my_isspace(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_SPC)
|
||||
#define my_ispunct(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_PNT)
|
||||
#define my_isprint(s, c) (((s)->ctype+1)[(uchar) (c)] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B))
|
||||
#define my_isgraph(s, c) (((s)->ctype+1)[(uchar) (c)] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR))
|
||||
#define my_iscntrl(s, c) (((s)->ctype+1)[(uchar) (c)] & _MY_CTR)
|
||||
|
||||
/* Some macros that should be cleaned up a little */
|
||||
#define my_isvar(s,c) (my_isalnum(s,c) || (c) == '_')
|
||||
#define my_isvar_start(s,c) (my_isalpha(s,c) || (c) == '_')
|
||||
|
||||
#define my_binary_compare(s) ((s)->state & MY_CS_BINSORT)
|
||||
#define use_strnxfrm(s) ((s)->state & MY_CS_STRNXFRM)
|
||||
#define my_strnxfrm(cs, d, dl, s, sl) \
|
||||
((cs)->coll->strnxfrm((cs), (d), (dl), (dl), (s), (sl), MY_STRXFRM_PAD_WITH_SPACE))
|
||||
#define my_strnncoll(s, a, b, c, d) ((s)->coll->strnncoll((s), (a), (b), (c), (d), 0))
|
||||
#define my_like_range(s, a, b, c, d, e, f, g, h, i, j) \
|
||||
((s)->coll->like_range((s), (a), (b), (c), (d), (e), (f), (g), (h), (i), (j)))
|
||||
#define my_wildcmp(cs,s,se,w,we,e,o,m) ((cs)->coll->wildcmp((cs),(s),(se),(w),(we),(e),(o),(m)))
|
||||
#define my_strcasecmp(s, a, b) ((s)->coll->strcasecmp((s), (a), (b)))
|
||||
#define my_charpos(cs, b, e, num) (cs)->cset->charpos((cs), (const char*) (b), (const char *)(e), (num))
|
||||
|
||||
|
||||
#define use_mb(s) ((s)->cset->ismbchar != NULL)
|
||||
#define my_ismbchar(s, a, b) ((s)->cset->ismbchar((s), (a), (b)))
|
||||
#define my_mbcharlen(s, a) ((s)->cset->mbcharlen((s),(a)))
|
||||
/**
|
||||
Get the length of gb18030 code by the given two leading bytes
|
||||
|
||||
@param[in] s charset_info
|
||||
@param[in] a first byte of gb18030 code
|
||||
@param[in] b second byte of gb18030 code
|
||||
@return the length of gb18030 code starting with given two bytes,
|
||||
the length would be 2 or 4 for valid gb18030 code,
|
||||
or 0 for invalid gb18030 code
|
||||
*/
|
||||
#define my_mbcharlen_2(s, a, b) ((s)->cset->mbcharlen((s),((((a) & 0xFF) << 8) + ((b) & 0xFF))))
|
||||
/**
|
||||
Get the maximum length of leading bytes needed to determine the length of a
|
||||
multi-byte gb18030 code
|
||||
|
||||
@param[in] s charset_info
|
||||
@return number of leading bytes we need, would be 2 for gb18030
|
||||
and 1 for all other charsets
|
||||
*/
|
||||
#define my_mbmaxlenlen(s) ((s)->mbmaxlenlen)
|
||||
/**
|
||||
Judge if the given byte is a possible leading byte for a charset.
|
||||
For gb18030 whose mbmaxlenlen is 2, we can't determine the length of
|
||||
a multi-byte character by looking at the first byte only
|
||||
|
||||
@param[in] s charset_info
|
||||
@param[in] i possible leading byte
|
||||
@return true if it is, otherwise false
|
||||
*/
|
||||
#define my_ismb1st(s, i) \
|
||||
(my_mbcharlen((s), (i)) > 1 || \
|
||||
(my_mbmaxlenlen((s)) == 2 && my_mbcharlen((s), (i)) == 0))
|
||||
|
||||
#define my_caseup_str(s, a) ((s)->cset->caseup_str((s), (a)))
|
||||
#define my_casedn_str(s, a) ((s)->cset->casedn_str((s), (a)))
|
||||
#define my_strntol(s, a, b, c, d, e) ((s)->cset->strntol((s),(a),(b),(c),(d),(e)))
|
||||
#define my_strntoul(s, a, b, c, d, e) ((s)->cset->strntoul((s),(a),(b),(c),(d),(e)))
|
||||
#define my_strntoll(s, a, b, c, d, e) ((s)->cset->strntoll((s),(a),(b),(c),(d),(e)))
|
||||
#define my_strntoull(s, a, b, c,d, e) ((s)->cset->strntoull((s),(a),(b),(c),(d),(e)))
|
||||
#define my_strntod(s, a, b, c, d) ((s)->cset->strntod((s),(a),(b),(c),(d)))
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _m_ctype_h */
|
|
@ -0,0 +1,351 @@
|
|||
/*
|
||||
Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef _m_string_h
|
||||
#define _m_string_h
|
||||
|
||||
#include "my_global.h" /* HAVE_* */
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#define bfill please_use_memset_rather_than_bfill
|
||||
#ifdef bzero
|
||||
#undef bzero
|
||||
#endif
|
||||
#define bzero please_use_memset_rather_than_bzero
|
||||
#define bmove please_use_memmove_rather_than_bmove
|
||||
#define strmov please_use_my_stpcpy_or_my_stpmov_rather_than_strmov
|
||||
#define strnmov please_use_my_stpncpy_or_my_stpnmov_rather_than_strnmov
|
||||
|
||||
#include "mysql/service_my_snprintf.h"
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
my_str_malloc(), my_str_realloc() and my_str_free() are assigned to
|
||||
implementations in strings/alloc.c, but can be overridden in
|
||||
the calling program.
|
||||
*/
|
||||
extern void *(*my_str_malloc)(size_t);
|
||||
extern void *(*my_str_realloc)(void *, size_t);
|
||||
extern void (*my_str_free)(void *);
|
||||
|
||||
/* Declared in int2str() */
|
||||
extern char _dig_vec_upper[];
|
||||
extern char _dig_vec_lower[];
|
||||
|
||||
/* Prototypes for string functions */
|
||||
|
||||
extern void bchange(uchar *dst,size_t old_len,const uchar *src,
|
||||
size_t new_len,size_t tot_len);
|
||||
extern void strappend(char *s,size_t len,pchar fill);
|
||||
extern char *strend(const char *s);
|
||||
extern char *strcend(const char *, pchar);
|
||||
extern char *strfill(char * s,size_t len,pchar fill);
|
||||
extern char *strmake(char *dst,const char *src,size_t length);
|
||||
|
||||
extern char *my_stpmov(char *dst,const char *src);
|
||||
extern char *my_stpnmov(char *dst, const char *src, size_t n);
|
||||
extern char *strcont(const char *src, const char *set);
|
||||
extern char *strxmov(char *dst, const char *src, ...);
|
||||
extern char *strxnmov(char *dst, size_t len, const char *src, ...);
|
||||
|
||||
/**
|
||||
Copy a string from src to dst until (and including) terminating null byte.
|
||||
|
||||
@param dst Destination
|
||||
@param src Source
|
||||
|
||||
@note src and dst cannot overlap.
|
||||
Use my_stpmov() if src and dst overlaps.
|
||||
|
||||
@note Unsafe, consider using my_stpnpy() instead.
|
||||
|
||||
@return pointer to terminating null byte.
|
||||
*/
|
||||
static inline char *my_stpcpy(char *dst, const char *src)
|
||||
{
|
||||
#if defined(HAVE_BUILTIN_STPCPY)
|
||||
return __builtin_stpcpy(dst, src);
|
||||
#elif defined(HAVE_STPCPY)
|
||||
return stpcpy(dst, src);
|
||||
#else
|
||||
/* Fallback to implementation supporting overlap. */
|
||||
return my_stpmov(dst, src);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Copy fixed-size string from src to dst.
|
||||
|
||||
@param dst Destination
|
||||
@param src Source
|
||||
@param n Maximum number of characters to copy.
|
||||
|
||||
@note src and dst cannot overlap
|
||||
Use my_stpnmov() if src and dst overlaps.
|
||||
|
||||
@return pointer to terminating null byte.
|
||||
*/
|
||||
static inline char *my_stpncpy(char *dst, const char *src, size_t n)
|
||||
{
|
||||
#if defined(HAVE_STPNCPY)
|
||||
return stpncpy(dst, src, n);
|
||||
#else
|
||||
/* Fallback to implementation supporting overlap. */
|
||||
return my_stpnmov(dst, src, n);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline longlong my_strtoll(const char *nptr, char **endptr, int base)
|
||||
{
|
||||
#if defined _WIN32
|
||||
return _strtoi64(nptr, endptr, base);
|
||||
#else
|
||||
return strtoll(nptr, endptr, base);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline ulonglong my_strtoull(const char *nptr, char **endptr, int base)
|
||||
{
|
||||
#if defined _WIN32
|
||||
return _strtoui64(nptr, endptr, base);
|
||||
#else
|
||||
return strtoull(nptr, endptr, base);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline char *my_strtok_r(char *str, const char *delim, char **saveptr)
|
||||
{
|
||||
#if defined _WIN32
|
||||
return strtok_s(str, delim, saveptr);
|
||||
#else
|
||||
return strtok_r(str, delim, saveptr);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* native_ rather than my_ since my_strcasecmp already exists */
|
||||
static inline int native_strcasecmp(const char *s1, const char *s2)
|
||||
{
|
||||
#if defined _WIN32
|
||||
return _stricmp(s1, s2);
|
||||
#else
|
||||
return strcasecmp(s1, s2);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* native_ rather than my_ for consistency with native_strcasecmp */
|
||||
static inline int native_strncasecmp(const char *s1, const char *s2, size_t n)
|
||||
{
|
||||
#if defined _WIN32
|
||||
return _strnicmp(s1, s2, n);
|
||||
#else
|
||||
return strncasecmp(s1, s2, n);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Prototypes of normal stringfunctions (with may ours) */
|
||||
#ifndef HAVE_STRNLEN
|
||||
extern size_t strnlen(const char *s, size_t n);
|
||||
#endif
|
||||
|
||||
extern int is_prefix(const char *, const char *);
|
||||
|
||||
/* Conversion routines */
|
||||
typedef enum {
|
||||
MY_GCVT_ARG_FLOAT,
|
||||
MY_GCVT_ARG_DOUBLE
|
||||
} my_gcvt_arg_type;
|
||||
|
||||
double my_strtod(const char *str, char **end, int *error);
|
||||
double my_atof(const char *nptr);
|
||||
size_t my_fcvt(double x, int precision, char *to, my_bool *error);
|
||||
size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
|
||||
my_bool *error);
|
||||
|
||||
#define NOT_FIXED_DEC 31
|
||||
|
||||
/*
|
||||
The longest string my_fcvt can return is 311 + "precision" bytes.
|
||||
Here we assume that we never cal my_fcvt() with precision >= NOT_FIXED_DEC
|
||||
(+ 1 byte for the terminating '\0').
|
||||
*/
|
||||
#define FLOATING_POINT_BUFFER (311 + NOT_FIXED_DEC)
|
||||
|
||||
/*
|
||||
We want to use the 'e' format in some cases even if we have enough space
|
||||
for the 'f' one just to mimic sprintf("%.15g") behavior for large integers,
|
||||
and to improve it for numbers < 10^(-4).
|
||||
That is, for |x| < 1 we require |x| >= 10^(-15), and for |x| > 1 we require
|
||||
it to be integer and be <= 10^DBL_DIG for the 'f' format to be used.
|
||||
We don't lose precision, but make cases like "1e200" or "0.00001" look nicer.
|
||||
*/
|
||||
#define MAX_DECPT_FOR_F_FORMAT DBL_DIG
|
||||
|
||||
/*
|
||||
The maximum possible field width for my_gcvt() conversion.
|
||||
(DBL_DIG + 2) significant digits + sign + "." + ("e-NNN" or
|
||||
MAX_DECPT_FOR_F_FORMAT zeros for cases when |x|<1 and the 'f' format is used).
|
||||
*/
|
||||
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + MY_MAX(5, MAX_DECPT_FOR_F_FORMAT)) \
|
||||
|
||||
extern char *llstr(longlong value,char *buff);
|
||||
extern char *ullstr(longlong value,char *buff);
|
||||
|
||||
extern char *int2str(long val, char *dst, int radix, int upcase);
|
||||
extern char *int10_to_str(long val,char *dst,int radix);
|
||||
extern char *str2int(const char *src,int radix,long lower,long upper,
|
||||
long *val);
|
||||
longlong my_strtoll10(const char *nptr, char **endptr, int *error);
|
||||
#if SIZEOF_LONG == SIZEOF_LONG_LONG
|
||||
#define ll2str(A,B,C,D) int2str((A),(B),(C),(D))
|
||||
#define longlong10_to_str(A,B,C) int10_to_str((A),(B),(C))
|
||||
#undef strtoll
|
||||
#define strtoll(A,B,C) strtol((A),(B),(C))
|
||||
#define strtoull(A,B,C) strtoul((A),(B),(C))
|
||||
#else
|
||||
extern char *ll2str(longlong val,char *dst,int radix, int upcase);
|
||||
extern char *longlong10_to_str(longlong val,char *dst,int radix);
|
||||
#endif
|
||||
#define longlong2str(A,B,C) ll2str((A),(B),(C),1)
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
LEX_STRING -- a pair of a C-string and its length.
|
||||
(it's part of the plugin API as a MYSQL_LEX_STRING)
|
||||
Ditto LEX_CSTRING/MYSQL_LEX_CSTRING.
|
||||
*/
|
||||
|
||||
#include <mysql/mysql_lex_string.h>
|
||||
typedef struct st_mysql_lex_string LEX_STRING;
|
||||
typedef struct st_mysql_const_lex_string LEX_CSTRING;
|
||||
|
||||
#define STRING_WITH_LEN(X) (X), ((sizeof(X) - 1))
|
||||
#define USTRING_WITH_LEN(X) ((uchar*) X), ((sizeof(X) - 1))
|
||||
#define C_STRING_WITH_LEN(X) ((char *) (X)), ((sizeof(X) - 1))
|
||||
|
||||
|
||||
/**
|
||||
Skip trailing space.
|
||||
|
||||
On most systems reading memory in larger chunks (ideally equal to the size of
|
||||
the chinks that the machine physically reads from memory) causes fewer memory
|
||||
access loops and hence increased performance.
|
||||
This is why the 'int' type is used : it's closest to that (according to how
|
||||
it's defined in C).
|
||||
So when we determine the amount of whitespace at the end of a string we do
|
||||
the following :
|
||||
1. We divide the string into 3 zones :
|
||||
a) from the start of the string (__start) to the first multiple
|
||||
of sizeof(int) (__start_words)
|
||||
b) from the end of the string (__end) to the last multiple of sizeof(int)
|
||||
(__end_words)
|
||||
c) a zone that is aligned to sizeof(int) and can be safely accessed
|
||||
through an int *
|
||||
2. We start comparing backwards from (c) char-by-char. If all we find is
|
||||
space then we continue
|
||||
3. If there are elements in zone (b) we compare them as unsigned ints to a
|
||||
int mask (SPACE_INT) consisting of all spaces
|
||||
4. Finally we compare the remaining part (a) of the string char by char.
|
||||
This covers for the last non-space unsigned int from 3. (if any)
|
||||
|
||||
This algorithm works well for relatively larger strings, but it will slow
|
||||
the things down for smaller strings (because of the additional calculations
|
||||
and checks compared to the naive method). Thus the barrier of length 20
|
||||
is added.
|
||||
|
||||
@param ptr pointer to the input string
|
||||
@param len the length of the string
|
||||
@return the last non-space character
|
||||
*/
|
||||
#if defined(__sparc) || defined(__sparcv9)
|
||||
static inline const uchar *skip_trailing_space(const uchar *ptr,size_t len)
|
||||
{
|
||||
/* SPACE_INT is a word that contains only spaces */
|
||||
#if SIZEOF_INT == 4
|
||||
const unsigned SPACE_INT= 0x20202020U;
|
||||
#elif SIZEOF_INT == 8
|
||||
const unsigned SPACE_INT= 0x2020202020202020ULL;
|
||||
#else
|
||||
#error define the appropriate constant for a word full of spaces
|
||||
#endif
|
||||
|
||||
const uchar *end= ptr + len;
|
||||
|
||||
if (len > 20)
|
||||
{
|
||||
const uchar *end_words= (const uchar *)(intptr)
|
||||
(((ulonglong)(intptr)end) / SIZEOF_INT * SIZEOF_INT);
|
||||
const uchar *start_words= (const uchar *)(intptr)
|
||||
((((ulonglong)(intptr)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
|
||||
|
||||
assert(end_words > ptr);
|
||||
while (end > end_words && end[-1] == 0x20)
|
||||
end--;
|
||||
if (end[-1] == 0x20 && start_words < end_words)
|
||||
while (end > start_words && ((unsigned *)end)[-1] == SPACE_INT)
|
||||
end -= SIZEOF_INT;
|
||||
}
|
||||
while (end > ptr && end[-1] == 0x20)
|
||||
end--;
|
||||
return (end);
|
||||
}
|
||||
#else
|
||||
/*
|
||||
Reads 8 bytes at a time, ignoring alignment.
|
||||
We use uint8korr, which is fast (it simply reads a *ulonglong)
|
||||
on all platforms, except sparc.
|
||||
*/
|
||||
static inline const uchar *skip_trailing_space(const uchar *ptr, size_t len)
|
||||
{
|
||||
const uchar *end= ptr + len;
|
||||
while (end - ptr >= 8)
|
||||
{
|
||||
if (uint8korr(end-8) != 0x2020202020202020ULL)
|
||||
break;
|
||||
end-= 8;
|
||||
}
|
||||
while (end > ptr && end[-1] == 0x20)
|
||||
end--;
|
||||
return (end);
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline void lex_string_set(LEX_STRING *lex_str, const char *c_str)
|
||||
{
|
||||
lex_str->str= (char *) c_str;
|
||||
lex_str->length= strlen(c_str);
|
||||
}
|
||||
|
||||
static inline void lex_cstring_set(LEX_CSTRING *lex_str, const char *c_str)
|
||||
{
|
||||
lex_str->str= c_str;
|
||||
lex_str->length= strlen(c_str);
|
||||
}
|
||||
|
||||
#endif
|
|
@ -0,0 +1,90 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
Data structures for mysys/my_alloc.c (root memory allocator)
|
||||
*/
|
||||
|
||||
#ifndef _my_alloc_h
|
||||
#define _my_alloc_h
|
||||
|
||||
#define ALLOC_MAX_BLOCK_TO_DROP 4096
|
||||
#define ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP 10
|
||||
|
||||
/* PSI_memory_key */
|
||||
#include "mysql/psi/psi_memory.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct st_used_mem
|
||||
{ /* struct for once_alloc (block) */
|
||||
struct st_used_mem *next; /* Next block in use */
|
||||
unsigned int left; /* memory left in block */
|
||||
unsigned int size; /* size of block */
|
||||
} USED_MEM;
|
||||
|
||||
|
||||
typedef struct st_mem_root
|
||||
{
|
||||
USED_MEM *free; /* blocks with free memory in it */
|
||||
USED_MEM *used; /* blocks almost without free memory */
|
||||
USED_MEM *pre_alloc; /* preallocated block */
|
||||
/* if block have less memory it will be put in 'used' list */
|
||||
size_t min_malloc;
|
||||
size_t block_size; /* initial block size */
|
||||
unsigned int block_num; /* allocated blocks counter */
|
||||
/*
|
||||
first free block in queue test counter (if it exceed
|
||||
MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
|
||||
*/
|
||||
unsigned int first_block_usage;
|
||||
|
||||
/*
|
||||
Maximum amount of memory this mem_root can hold. A value of 0
|
||||
implies there is no limit.
|
||||
*/
|
||||
size_t max_capacity;
|
||||
|
||||
/* Allocated size for this mem_root */
|
||||
|
||||
size_t allocated_size;
|
||||
|
||||
/* Enable this for error reporting if capacity is exceeded */
|
||||
my_bool error_for_capacity_exceeded;
|
||||
|
||||
void (*error_handler)(void);
|
||||
|
||||
PSI_memory_key m_psi_key;
|
||||
} MEM_ROOT;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,225 @@
|
|||
#ifndef MY_BYTEORDER_INCLUDED
|
||||
#define MY_BYTEORDER_INCLUDED
|
||||
|
||||
/* Copyright (c) 2001, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
|
||||
/*
|
||||
Functions for reading and storing in machine independent
|
||||
format (low byte first). There are 'korr' (assume 'corrector') variants
|
||||
for integer types, but 'get' (assume 'getter') for floating point types.
|
||||
*/
|
||||
#if defined(__i386__) || defined(_WIN32) || defined(__x86_64__)
|
||||
#include "byte_order_generic_x86.h"
|
||||
#else
|
||||
#include "byte_order_generic.h"
|
||||
#endif
|
||||
|
||||
static inline int32 sint3korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
((int32) (((A[2]) & 128) ?
|
||||
(((uint32) 255L << 24) |
|
||||
(((uint32) A[2]) << 16) |
|
||||
(((uint32) A[1]) << 8) |
|
||||
((uint32) A[0])) :
|
||||
(((uint32) A[2]) << 16) |
|
||||
(((uint32) A[1]) << 8) |
|
||||
((uint32) A[0])))
|
||||
;
|
||||
}
|
||||
|
||||
static inline uint32 uint3korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
(uint32) (((uint32) (A[0])) +
|
||||
(((uint32) (A[1])) << 8) +
|
||||
(((uint32) (A[2])) << 16))
|
||||
;
|
||||
}
|
||||
|
||||
static inline ulonglong uint5korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
((ulonglong)(((uint32) (A[0])) +
|
||||
(((uint32) (A[1])) << 8) +
|
||||
(((uint32) (A[2])) << 16) +
|
||||
(((uint32) (A[3])) << 24)) +
|
||||
(((ulonglong) (A[4])) << 32))
|
||||
;
|
||||
}
|
||||
|
||||
static inline ulonglong uint6korr(const uchar *A)
|
||||
{
|
||||
return
|
||||
((ulonglong)(((uint32) (A[0])) +
|
||||
(((uint32) (A[1])) << 8) +
|
||||
(((uint32) (A[2])) << 16) +
|
||||
(((uint32) (A[3])) << 24)) +
|
||||
(((ulonglong) (A[4])) << 32) +
|
||||
(((ulonglong) (A[5])) << 40))
|
||||
;
|
||||
}
|
||||
|
||||
static inline void int3store(uchar *T, uint A)
|
||||
{
|
||||
*(T)= (uchar) (A);
|
||||
*(T+1)= (uchar) (A >> 8);
|
||||
*(T+2)= (uchar) (A >> 16);
|
||||
}
|
||||
|
||||
static inline void int5store(uchar *T, ulonglong A)
|
||||
{
|
||||
*(T)= (uchar) (A);
|
||||
*(T+1)= (uchar) (A >> 8);
|
||||
*(T+2)= (uchar) (A >> 16);
|
||||
*(T+3)= (uchar) (A >> 24);
|
||||
*(T+4)= (uchar) (A >> 32);
|
||||
}
|
||||
|
||||
static inline void int6store(uchar *T, ulonglong A)
|
||||
{
|
||||
*(T)= (uchar) (A);
|
||||
*(T+1)= (uchar) (A >> 8);
|
||||
*(T+2)= (uchar) (A >> 16);
|
||||
*(T+3)= (uchar) (A >> 24);
|
||||
*(T+4)= (uchar) (A >> 32);
|
||||
*(T+5)= (uchar) (A >> 40);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
static inline int16 sint2korr(const char *pT)
|
||||
{
|
||||
return sint2korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline uint16 uint2korr(const char *pT)
|
||||
{
|
||||
return uint2korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline uint32 uint3korr(const char *pT)
|
||||
{
|
||||
return uint3korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline int32 sint3korr(const char *pT)
|
||||
{
|
||||
return sint3korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline uint32 uint4korr(const char *pT)
|
||||
{
|
||||
return uint4korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline int32 sint4korr(const char *pT)
|
||||
{
|
||||
return sint4korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline ulonglong uint6korr(const char *pT)
|
||||
{
|
||||
return uint6korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline ulonglong uint8korr(const char *pT)
|
||||
{
|
||||
return uint8korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
static inline longlong sint8korr(const char *pT)
|
||||
{
|
||||
return sint8korr(static_cast<const uchar*>(static_cast<const void*>(pT)));
|
||||
}
|
||||
|
||||
|
||||
static inline void int2store(char *pT, uint16 A)
|
||||
{
|
||||
int2store(static_cast<uchar*>(static_cast<void*>(pT)), A);
|
||||
}
|
||||
|
||||
static inline void int3store(char *pT, uint A)
|
||||
{
|
||||
int3store(static_cast<uchar*>(static_cast<void*>(pT)), A);
|
||||
}
|
||||
|
||||
static inline void int4store(char *pT, uint32 A)
|
||||
{
|
||||
int4store(static_cast<uchar*>(static_cast<void*>(pT)), A);
|
||||
}
|
||||
|
||||
static inline void int5store(char *pT, ulonglong A)
|
||||
{
|
||||
int5store(static_cast<uchar*>(static_cast<void*>(pT)), A);
|
||||
}
|
||||
|
||||
static inline void int6store(char *pT, ulonglong A)
|
||||
{
|
||||
int6store(static_cast<uchar*>(static_cast<void*>(pT)), A);
|
||||
}
|
||||
|
||||
static inline void int8store(char *pT, ulonglong A)
|
||||
{
|
||||
int8store(static_cast<uchar*>(static_cast<void*>(pT)), A);
|
||||
}
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*
|
||||
Functions for reading and storing in machine format from/to
|
||||
short/long to/from some place in memory V should be a variable
|
||||
and M a pointer to byte.
|
||||
*/
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
#include "big_endian.h"
|
||||
#else
|
||||
#include "little_endian.h"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
static inline void float4store(char *V, float M)
|
||||
{
|
||||
float4store(static_cast<uchar*>(static_cast<void*>(V)), M);
|
||||
}
|
||||
|
||||
static inline void float8get(double *V, const char *M)
|
||||
{
|
||||
float8get(V, static_cast<const uchar*>(static_cast<const void*>(M)));
|
||||
}
|
||||
|
||||
static inline void float8store(char *V, double M)
|
||||
{
|
||||
float8store(static_cast<uchar*>(static_cast<void*>(V)), M);
|
||||
}
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* MY_BYTEORDER_INCLUDED */
|
|
@ -28,76 +28,49 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|||
#ifndef _mysql_command_h
|
||||
#define _mysql_command_h
|
||||
|
||||
/**
|
||||
@file include/my_command.h
|
||||
*/
|
||||
|
||||
/**
|
||||
@enum enum_server_command
|
||||
|
||||
@brief A list of all MySQL protocol commands.
|
||||
|
||||
These are the top level commands the server can receive
|
||||
while it listens for a new command in ::dispatch_command
|
||||
|
||||
@par Warning
|
||||
Add new commands to the end of this list, otherwise old
|
||||
servers won't be able to handle them as 'unsupported'.
|
||||
@brief You should add new commands to the end of this list, otherwise old
|
||||
servers won't be able to handle them as 'unsupported'.
|
||||
*/
|
||||
enum enum_server_command {
|
||||
/**
|
||||
Currently refused by the server. See ::dispatch_command.
|
||||
Also used internally to mark the start of a session.
|
||||
*/
|
||||
enum enum_server_command
|
||||
{
|
||||
COM_SLEEP,
|
||||
COM_QUIT, /**< See @ref page_protocol_com_quit */
|
||||
COM_INIT_DB, /**< See @ref page_protocol_com_init_db */
|
||||
COM_QUERY, /**< See @ref page_protocol_com_query */
|
||||
COM_FIELD_LIST, /**< Deprecated. See @ref page_protocol_com_field_list */
|
||||
COM_CREATE_DB, /**< Currently refused by the server. See ::dispatch_command */
|
||||
COM_DROP_DB, /**< Currently refused by the server. See ::dispatch_command */
|
||||
COM_REFRESH, /**< Deprecated. See @ref page_protocol_com_refresh */
|
||||
COM_DEPRECATED_1, /**< Deprecated, used to be COM_SHUTDOWN */
|
||||
COM_STATISTICS, /**< See @ref page_protocol_com_statistics */
|
||||
COM_PROCESS_INFO, /**< Deprecated. See @ref page_protocol_com_process_info */
|
||||
COM_CONNECT, /**< Currently refused by the server. */
|
||||
COM_PROCESS_KILL, /**< Deprecated. See @ref page_protocol_com_process_kill */
|
||||
COM_DEBUG, /**< See @ref page_protocol_com_debug */
|
||||
COM_PING, /**< See @ref page_protocol_com_ping */
|
||||
COM_TIME, /**< Currently refused by the server. */
|
||||
COM_DELAYED_INSERT, /**< Functionality removed. */
|
||||
COM_CHANGE_USER, /**< See @ref page_protocol_com_change_user */
|
||||
COM_BINLOG_DUMP, /**< See @ref page_protocol_com_binlog_dump */
|
||||
COM_QUIT,
|
||||
COM_INIT_DB,
|
||||
COM_QUERY,
|
||||
COM_FIELD_LIST,
|
||||
COM_CREATE_DB,
|
||||
COM_DROP_DB,
|
||||
COM_REFRESH,
|
||||
COM_SHUTDOWN,
|
||||
COM_STATISTICS,
|
||||
COM_PROCESS_INFO,
|
||||
COM_CONNECT,
|
||||
COM_PROCESS_KILL,
|
||||
COM_DEBUG,
|
||||
COM_PING,
|
||||
COM_TIME,
|
||||
COM_DELAYED_INSERT,
|
||||
COM_CHANGE_USER,
|
||||
COM_BINLOG_DUMP,
|
||||
COM_TABLE_DUMP,
|
||||
COM_CONNECT_OUT,
|
||||
COM_REGISTER_SLAVE,
|
||||
COM_STMT_PREPARE, /**< See @ref page_protocol_com_stmt_prepare */
|
||||
COM_STMT_EXECUTE, /**< See @ref page_protocol_com_stmt_execute */
|
||||
/** See @ref page_protocol_com_stmt_send_long_data */
|
||||
COM_STMT_PREPARE,
|
||||
COM_STMT_EXECUTE,
|
||||
COM_STMT_SEND_LONG_DATA,
|
||||
COM_STMT_CLOSE, /**< See @ref page_protocol_com_stmt_close */
|
||||
COM_STMT_RESET, /**< See @ref page_protocol_com_stmt_reset */
|
||||
COM_SET_OPTION, /**< See @ref page_protocol_com_set_option */
|
||||
COM_STMT_FETCH, /**< See @ref page_protocol_com_stmt_fetch */
|
||||
/**
|
||||
Currently refused by the server. See ::dispatch_command.
|
||||
Also used internally to mark the session as a "daemon",
|
||||
i.e. non-client THD. Currently the scheduler and the GTID
|
||||
code does use this state.
|
||||
These threads won't be killed by `KILL`
|
||||
|
||||
@sa Event_scheduler::start, ::init_thd, ::kill_one_thread,
|
||||
::Find_thd_with_id
|
||||
*/
|
||||
COM_STMT_CLOSE,
|
||||
COM_STMT_RESET,
|
||||
COM_SET_OPTION,
|
||||
COM_STMT_FETCH,
|
||||
COM_DAEMON,
|
||||
COM_BINLOG_DUMP_GTID,
|
||||
COM_RESET_CONNECTION, /**< See @ref page_protocol_com_reset_connection */
|
||||
COM_CLONE,
|
||||
COM_SUBSCRIBE_GROUP_REPLICATION_STREAM,
|
||||
COM_RESET_CONNECTION,
|
||||
/* don't forget to update const char *command_name[] in sql_parse.cc */
|
||||
|
||||
/* Must be last */
|
||||
COM_END /**< Not a real command. Refused. */
|
||||
COM_END
|
||||
};
|
||||
|
||||
#endif /* _mysql_command_h */
|
||||
|
|
|
@ -0,0 +1,190 @@
|
|||
#ifndef MY_COMPILER_INCLUDED
|
||||
#define MY_COMPILER_INCLUDED
|
||||
|
||||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
Header for compiler-dependent features.
|
||||
|
||||
Intended to contain a set of reusable wrappers for preprocessor
|
||||
macros, attributes, pragmas, and any other features that are
|
||||
specific to a target compiler.
|
||||
*/
|
||||
|
||||
#include <stddef.h> /* size_t */
|
||||
|
||||
#if defined __GNUC__
|
||||
/*
|
||||
Convenience macro to test the minimum required GCC version.
|
||||
These should be used with care as Clang also sets __GNUC__ and
|
||||
__GNUC_MINOR__ (currently to 4.2). Prefer using feature specific
|
||||
CMake checks in configure.cmake instead.
|
||||
*/
|
||||
# define MY_GNUC_PREREQ(maj, min) \
|
||||
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
|
||||
# define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
|
||||
#else
|
||||
# define MY_GNUC_PREREQ(maj, min) (0)
|
||||
#endif
|
||||
|
||||
/*
|
||||
The macros below are borrowed from include/linux/compiler.h in the
|
||||
Linux kernel. Use them to indicate the likelyhood of the truthfulness
|
||||
of a condition. This serves two purposes - newer versions of gcc will be
|
||||
able to optimize for branch predication, which could yield siginficant
|
||||
performance gains in frequently executed sections of the code, and the
|
||||
other reason to use them is for documentation
|
||||
*/
|
||||
#ifdef HAVE_BUILTIN_EXPECT
|
||||
|
||||
// likely/unlikely are likely to clash with other symbols, do not #define
|
||||
#if defined(__cplusplus)
|
||||
inline bool likely(bool expr)
|
||||
{
|
||||
return __builtin_expect(expr, true);
|
||||
}
|
||||
inline bool unlikely(bool expr)
|
||||
{
|
||||
return __builtin_expect(expr, false);
|
||||
}
|
||||
#else
|
||||
# define likely(x) __builtin_expect((x),1)
|
||||
# define unlikely(x) __builtin_expect((x),0)
|
||||
#endif
|
||||
|
||||
#else /* HAVE_BUILTIN_EXPECT */
|
||||
|
||||
#if defined(__cplusplus)
|
||||
inline bool likely(bool expr)
|
||||
{
|
||||
return expr;
|
||||
}
|
||||
inline bool unlikely(bool expr)
|
||||
{
|
||||
return expr;
|
||||
}
|
||||
#else
|
||||
# define likely(x) (x)
|
||||
# define unlikely(x) (x)
|
||||
#endif
|
||||
|
||||
#endif /* HAVE_BUILTIN_EXPECT */
|
||||
|
||||
/* Comunicate to the compiler the unreachability of the code. */
|
||||
#ifdef HAVE_BUILTIN_UNREACHABLE
|
||||
# define MY_ASSERT_UNREACHABLE() __builtin_unreachable()
|
||||
#else
|
||||
# define MY_ASSERT_UNREACHABLE() do { assert(0); } while (0)
|
||||
#endif
|
||||
|
||||
#if defined __GNUC__ || defined __SUNPRO_C || defined __SUNPRO_CC
|
||||
/* Specifies the minimum alignment of a type. */
|
||||
# define MY_ALIGNOF(type) __alignof__(type)
|
||||
/* Determine the alignment requirement of a type. */
|
||||
# define MY_ALIGNED(n) __attribute__((__aligned__((n))))
|
||||
/* Microsoft Visual C++ */
|
||||
#elif defined _MSC_VER
|
||||
# define MY_ALIGNOF(type) __alignof(type)
|
||||
# define MY_ALIGNED(n) __declspec(align(n))
|
||||
#else /* Make sure they are defined for other compilers. */
|
||||
# define MY_ALIGNOF(type)
|
||||
# define MY_ALIGNED(size)
|
||||
#endif
|
||||
|
||||
/* Visual Studio requires '__inline' for C code */
|
||||
#if !defined(__cplusplus) && defined(_MSC_VER)
|
||||
# define inline __inline
|
||||
#endif
|
||||
|
||||
/* Provide __func__ macro definition for Visual Studio. */
|
||||
#if defined(_MSC_VER)
|
||||
# define __func__ __FUNCTION__
|
||||
#endif
|
||||
|
||||
/**
|
||||
C++ Type Traits
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
|
||||
/**
|
||||
Opaque storage with a particular alignment.
|
||||
Partial specialization used due to MSVC++.
|
||||
*/
|
||||
template<size_t alignment> struct my_alignment_imp;
|
||||
template<> struct MY_ALIGNED(1) my_alignment_imp<1> {};
|
||||
template<> struct MY_ALIGNED(2) my_alignment_imp<2> {};
|
||||
template<> struct MY_ALIGNED(4) my_alignment_imp<4> {};
|
||||
template<> struct MY_ALIGNED(8) my_alignment_imp<8> {};
|
||||
template<> struct MY_ALIGNED(16) my_alignment_imp<16> {};
|
||||
|
||||
/**
|
||||
A POD type with a given size and alignment.
|
||||
|
||||
@remark If the compiler does not support a alignment attribute
|
||||
(MY_ALIGN macro), the default alignment of a double is
|
||||
used instead.
|
||||
|
||||
@tparam size The minimum size.
|
||||
@tparam alignment The desired alignment: 1, 2, 4, 8 or 16.
|
||||
*/
|
||||
template <size_t size, size_t alignment>
|
||||
struct my_aligned_storage
|
||||
{
|
||||
union
|
||||
{
|
||||
char data[size];
|
||||
my_alignment_imp<alignment> align;
|
||||
};
|
||||
};
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*
|
||||
Disable MY_ATTRIBUTE for Sun Studio and Visual Studio.
|
||||
Note that Sun Studio supports some __attribute__ variants,
|
||||
but not format or unused which we use quite a lot.
|
||||
*/
|
||||
#ifndef MY_ATTRIBUTE
|
||||
#if defined(__GNUC__)
|
||||
# define MY_ATTRIBUTE(A) __attribute__(A)
|
||||
#else
|
||||
# define MY_ATTRIBUTE(A)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __has_attribute
|
||||
# define __has_attribute(x) 0
|
||||
#endif
|
||||
|
||||
#if __has_attribute(no_sanitize_undefined)
|
||||
# define SUPPRESS_UBSAN __attribute__((no_sanitize_undefined))
|
||||
#else
|
||||
# define SUPPRESS_UBSAN
|
||||
#endif
|
||||
|
||||
#endif /* MY_COMPILER_INCLUDED */
|
|
@ -1,114 +0,0 @@
|
|||
/* Copyright (c) 2019, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MY_COMPRESS_INCLUDED
|
||||
#define MY_COMPRESS_INCLUDED
|
||||
|
||||
/* List of valid values for compression_algorithm */
|
||||
enum enum_compression_algorithm {
|
||||
MYSQL_UNCOMPRESSED = 1,
|
||||
MYSQL_ZLIB,
|
||||
MYSQL_ZSTD,
|
||||
MYSQL_INVALID
|
||||
};
|
||||
|
||||
/**
|
||||
Compress context information. relating to zlib compression.
|
||||
*/
|
||||
|
||||
typedef struct mysql_zlib_compress_context {
|
||||
/**
|
||||
Compression level to use in zlib compression.
|
||||
*/
|
||||
unsigned int compression_level;
|
||||
} mysql_zlib_compress_context;
|
||||
|
||||
typedef struct ZSTD_CCtx_s ZSTD_CCtx;
|
||||
typedef struct ZSTD_DCtx_s ZSTD_DCtx;
|
||||
|
||||
/**
|
||||
Compress context information relating to zstd compression.
|
||||
*/
|
||||
|
||||
typedef struct mysql_zstd_compress_context {
|
||||
/**
|
||||
Pointer to compressor context.
|
||||
*/
|
||||
ZSTD_CCtx *cctx;
|
||||
/**
|
||||
Pointer to decompressor context.
|
||||
*/
|
||||
ZSTD_DCtx *dctx;
|
||||
/**
|
||||
Compression level to use in zstd compression.
|
||||
*/
|
||||
unsigned int compression_level;
|
||||
} mysql_zstd_compress_context;
|
||||
|
||||
/**
|
||||
Compression context information.
|
||||
It encapsulate the context information based on compression method and
|
||||
presents a generic struct.
|
||||
*/
|
||||
|
||||
typedef struct mysql_compress_context {
|
||||
enum enum_compression_algorithm algorithm; ///< Compression algorithm name.
|
||||
union {
|
||||
mysql_zlib_compress_context zlib_ctx; ///< Context information of zlib.
|
||||
mysql_zstd_compress_context zstd_ctx; ///< Context information of zstd.
|
||||
} u;
|
||||
} mysql_compress_context;
|
||||
|
||||
/**
|
||||
Get default compression level corresponding to a given compression method.
|
||||
|
||||
@param algorithm Compression Method. Possible values are zlib or zstd.
|
||||
|
||||
@return an unsigned int representing default compression level.
|
||||
6 is the default compression level for zlib and 3 is the
|
||||
default compression level for zstd.
|
||||
*/
|
||||
|
||||
unsigned int mysql_default_compression_level(
|
||||
enum enum_compression_algorithm algorithm);
|
||||
|
||||
/**
|
||||
Initialize a compress context object to be associated with a NET object.
|
||||
|
||||
@param cmp_ctx Pointer to compression context.
|
||||
@param algorithm Compression algorithm.
|
||||
@param compression_level Compression level corresponding to the compression
|
||||
algorithm.
|
||||
*/
|
||||
|
||||
void mysql_compress_context_init(mysql_compress_context *cmp_ctx,
|
||||
enum enum_compression_algorithm algorithm,
|
||||
unsigned int compression_level);
|
||||
/**
|
||||
Deinitialize the compression context allocated.
|
||||
|
||||
@param mysql_compress_ctx Pointer to Compression context.
|
||||
*/
|
||||
|
||||
void mysql_compress_context_deinit(mysql_compress_context *mysql_compress_ctx);
|
||||
|
||||
#endif // MY_COMPRESS_INCLUDED
|
|
@ -0,0 +1,469 @@
|
|||
/* Copyright (c) 2009, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MY_CONFIG_H
|
||||
#define MY_CONFIG_H
|
||||
|
||||
/*
|
||||
* From configure.cmake, in order of appearance
|
||||
*/
|
||||
/* #undef HAVE_LLVM_LIBCPP */
|
||||
#define _LARGEFILE_SOURCE 1
|
||||
|
||||
/* Libraries */
|
||||
/* #undef HAVE_LIBM */
|
||||
/* #undef HAVE_LIBNSL */
|
||||
/* #undef HAVE_LIBCRYPT */
|
||||
/* #undef HAVE_LIBSOCKET */
|
||||
/* #undef HAVE_LIBDL */
|
||||
/* #undef HAVE_LIBRT */
|
||||
/* #undef HAVE_LIBWRAP */
|
||||
/* #undef HAVE_LIBWRAP_PROTOTYPES */
|
||||
|
||||
/* Header files */
|
||||
/* #undef HAVE_ALLOCA_H */
|
||||
/* #undef HAVE_ARPA_INET_H */
|
||||
/* #undef HAVE_CRYPT_H */
|
||||
/* #undef HAVE_DLFCN_H */
|
||||
/* #undef HAVE_EXECINFO_H */
|
||||
/* #undef HAVE_FPU_CONTROL_H */
|
||||
/* #undef HAVE_GRP_H */
|
||||
/* #undef HAVE_IEEEFP_H */
|
||||
/* #undef HAVE_LANGINFO_H */
|
||||
#define HAVE_MALLOC_H 1
|
||||
/* #undef HAVE_NETINET_IN_H */
|
||||
/* #undef HAVE_POLL_H */
|
||||
/* #undef HAVE_PWD_H */
|
||||
/* #undef HAVE_STRINGS_H */
|
||||
/* #undef HAVE_SYS_CDEFS_H */
|
||||
/* #undef HAVE_SYS_IOCTL_H */
|
||||
/* #undef HAVE_SYS_MMAN_H */
|
||||
/* #undef HAVE_SYS_RESOURCE_H */
|
||||
/* #undef HAVE_SYS_SELECT_H */
|
||||
/* #undef HAVE_SYS_SOCKET_H */
|
||||
/* #undef HAVE_TERM_H */
|
||||
/* #undef HAVE_TERMIOS_H */
|
||||
/* #undef HAVE_TERMIO_H */
|
||||
/* #undef HAVE_UNISTD_H */
|
||||
/* #undef HAVE_SYS_WAIT_H */
|
||||
/* #undef HAVE_SYS_PARAM_H */
|
||||
/* #undef HAVE_FNMATCH_H */
|
||||
/* #undef HAVE_SYS_UN_H */
|
||||
/* #undef HAVE_SASL_SASL_H */
|
||||
|
||||
/* Libevent */
|
||||
/* #undef HAVE_DEVPOLL */
|
||||
/* #undef HAVE_SYS_DEVPOLL_H */
|
||||
/* #undef HAVE_SYS_EPOLL_H */
|
||||
/* #undef HAVE_TAILQFOREACH */
|
||||
|
||||
/* Functions */
|
||||
#define HAVE_ALIGNED_MALLOC 1
|
||||
/* #undef HAVE_BACKTRACE */
|
||||
/* #undef HAVE_PRINTSTACK */
|
||||
/* #undef HAVE_INDEX */
|
||||
/* #undef HAVE_CLOCK_GETTIME */
|
||||
/* #undef HAVE_CUSERID */
|
||||
/* #undef HAVE_DIRECTIO */
|
||||
/* #undef HAVE_FTRUNCATE */
|
||||
#define HAVE_COMPRESS 1
|
||||
/* #undef HAVE_CRYPT */
|
||||
/* #undef HAVE_DLOPEN */
|
||||
/* #undef HAVE_FCHMOD */
|
||||
/* #undef HAVE_FCNTL */
|
||||
/* #undef HAVE_FDATASYNC */
|
||||
/* #undef HAVE_DECL_FDATASYNC */
|
||||
/* #undef HAVE_FEDISABLEEXCEPT */
|
||||
/* #undef HAVE_FSEEKO */
|
||||
/* #undef HAVE_FSYNC */
|
||||
/* #undef HAVE_GETHOSTBYADDR_R */
|
||||
/* #undef HAVE_GETHRTIME */
|
||||
/* #undef HAVE_GETNAMEINFO */
|
||||
/* #undef HAVE_GETPASS */
|
||||
/* #undef HAVE_GETPASSPHRASE */
|
||||
/* #undef HAVE_GETPWNAM */
|
||||
/* #undef HAVE_GETPWUID */
|
||||
/* #undef HAVE_GETRLIMIT */
|
||||
/* #undef HAVE_GETRUSAGE */
|
||||
/* #undef HAVE_INITGROUPS */
|
||||
/* #undef HAVE_ISSETUGID */
|
||||
/* #undef HAVE_GETUID */
|
||||
/* #undef HAVE_GETEUID */
|
||||
/* #undef HAVE_GETGID */
|
||||
/* #undef HAVE_GETEGID */
|
||||
/* #undef HAVE_LSTAT */
|
||||
/* #undef HAVE_MADVISE */
|
||||
/* #undef HAVE_MALLOC_INFO */
|
||||
/* #undef HAVE_MEMRCHR */
|
||||
/* #undef HAVE_MLOCK */
|
||||
/* #undef HAVE_MLOCKALL */
|
||||
/* #undef HAVE_MMAP64 */
|
||||
/* #undef HAVE_POLL */
|
||||
/* #undef HAVE_POSIX_FALLOCATE */
|
||||
/* #undef HAVE_POSIX_MEMALIGN */
|
||||
/* #undef HAVE_PREAD */
|
||||
/* #undef HAVE_PTHREAD_CONDATTR_SETCLOCK */
|
||||
/* #undef HAVE_PTHREAD_SIGMASK */
|
||||
/* #undef HAVE_READLINK */
|
||||
/* #undef HAVE_REALPATH */
|
||||
/* #undef HAVE_SETFD */
|
||||
/* #undef HAVE_SIGACTION */
|
||||
/* #undef HAVE_SLEEP */
|
||||
/* #undef HAVE_STPCPY */
|
||||
/* #undef HAVE_STPNCPY */
|
||||
/* #undef HAVE_STRLCPY */
|
||||
#define HAVE_STRNLEN 1
|
||||
/* #undef HAVE_STRLCAT */
|
||||
/* #undef HAVE_STRSIGNAL */
|
||||
/* #undef HAVE_FGETLN */
|
||||
/* #undef HAVE_STRSEP */
|
||||
#define HAVE_TELL 1
|
||||
/* #undef HAVE_VASPRINTF */
|
||||
/* #undef HAVE_MEMALIGN */
|
||||
/* #undef HAVE_NL_LANGINFO */
|
||||
/* #undef HAVE_HTONLL */
|
||||
/* #undef DNS_USE_CPU_CLOCK_FOR_ID */
|
||||
/* #undef HAVE_EPOLL */
|
||||
/* #undef HAVE_EVENT_PORTS */
|
||||
/* #undef HAVE_INET_NTOP */
|
||||
/* #undef HAVE_WORKING_KQUEUE */
|
||||
/* #undef HAVE_TIMERADD */
|
||||
/* #undef HAVE_TIMERCLEAR */
|
||||
/* #undef HAVE_TIMERCMP */
|
||||
/* #undef HAVE_TIMERISSET */
|
||||
|
||||
/* WL2373 */
|
||||
/* #undef HAVE_SYS_TIME_H */
|
||||
/* #undef HAVE_SYS_TIMES_H */
|
||||
/* #undef HAVE_TIMES */
|
||||
/* #undef HAVE_GETTIMEOFDAY */
|
||||
|
||||
/* Symbols */
|
||||
/* #undef HAVE_LRAND48 */
|
||||
/* #undef GWINSZ_IN_SYS_IOCTL */
|
||||
/* #undef FIONREAD_IN_SYS_IOCTL */
|
||||
/* #undef FIONREAD_IN_SYS_FILIO */
|
||||
/* #undef HAVE_SIGEV_THREAD_ID */
|
||||
/* #undef HAVE_SIGEV_PORT */
|
||||
#define HAVE_LOG2 1
|
||||
|
||||
#define HAVE_ISINF 1
|
||||
|
||||
/* #undef HAVE_KQUEUE_TIMERS */
|
||||
/* #undef HAVE_POSIX_TIMERS */
|
||||
|
||||
/* Endianess */
|
||||
/* #undef WORDS_BIGENDIAN */
|
||||
|
||||
/* Type sizes */
|
||||
#define SIZEOF_VOIDP 4
|
||||
#define SIZEOF_CHARP 4
|
||||
#define SIZEOF_LONG 4
|
||||
#define SIZEOF_SHORT 2
|
||||
#define SIZEOF_INT 4
|
||||
#define SIZEOF_LONG_LONG 8
|
||||
#define SIZEOF_OFF_T 4
|
||||
#define SIZEOF_TIME_T 8
|
||||
/* #undef HAVE_UINT */
|
||||
/* #undef HAVE_ULONG */
|
||||
/* #undef HAVE_U_INT32_T */
|
||||
#define HAVE_STRUCT_TIMESPEC
|
||||
|
||||
/* Support for tagging symbols with __attribute__((visibility("hidden"))) */
|
||||
/* #undef HAVE_VISIBILITY_HIDDEN */
|
||||
|
||||
/* Code tests*/
|
||||
#define STACK_DIRECTION -1
|
||||
/* #undef TIME_WITH_SYS_TIME */
|
||||
#define NO_FCNTL_NONBLOCK 1
|
||||
/* #undef HAVE_PAUSE_INSTRUCTION */
|
||||
/* #undef HAVE_FAKE_PAUSE_INSTRUCTION */
|
||||
/* #undef HAVE_HMT_PRIORITY_INSTRUCTION */
|
||||
/* #undef HAVE_ABI_CXA_DEMANGLE */
|
||||
/* #undef HAVE_BUILTIN_UNREACHABLE */
|
||||
/* #undef HAVE_BUILTIN_EXPECT */
|
||||
/* #undef HAVE_BUILTIN_STPCPY */
|
||||
/* #undef HAVE_GCC_ATOMIC_BUILTINS */
|
||||
/* #undef HAVE_GCC_SYNC_BUILTINS */
|
||||
/* #undef HAVE_VALGRIND */
|
||||
/* #undef HAVE_PTHREAD_THREADID_NP */
|
||||
|
||||
/* IPV6 */
|
||||
/* #undef HAVE_NETINET_IN6_H */
|
||||
#define HAVE_STRUCT_SOCKADDR_IN6 1
|
||||
#define HAVE_STRUCT_IN6_ADDR 1
|
||||
#define HAVE_IPV6 1
|
||||
|
||||
/* #undef ss_family */
|
||||
/* #undef HAVE_SOCKADDR_IN_SIN_LEN */
|
||||
/* #undef HAVE_SOCKADDR_IN6_SIN6_LEN */
|
||||
|
||||
/*
|
||||
* Platform specific CMake files
|
||||
*/
|
||||
#define MACHINE_TYPE "AMD64"
|
||||
/* #undef HAVE_LINUX_LARGE_PAGES */
|
||||
/* #undef HAVE_SOLARIS_LARGE_PAGES */
|
||||
/* #undef HAVE_SOLARIS_ATOMIC */
|
||||
/* #undef HAVE_SOLARIS_STYLE_GETHOST */
|
||||
#define SYSTEM_TYPE "Win32"
|
||||
/* Windows stuff, mostly functions, that have Posix analogs but named differently */
|
||||
/* #undef IPPROTO_IPV6 */
|
||||
/* #undef IPV6_V6ONLY */
|
||||
/* This should mean case insensitive file system */
|
||||
#define FN_NO_CASE_SENSE 1
|
||||
/* #undef APPLE_ARM */
|
||||
|
||||
/*
|
||||
* From main CMakeLists.txt
|
||||
*/
|
||||
#define MAX_INDEXES 64U
|
||||
/* #undef WITH_INNODB_MEMCACHED */
|
||||
/* #undef ENABLE_MEMCACHED_SASL */
|
||||
/* #undef ENABLE_MEMCACHED_SASL_PWDB */
|
||||
#define ENABLED_PROFILING 1
|
||||
/* #undef HAVE_ASAN */
|
||||
#define ENABLED_LOCAL_INFILE 1
|
||||
#define OPTIMIZER_TRACE 1
|
||||
#define DEFAULT_MYSQL_HOME "C:/Program Files/MySQL/MySQL Server 5.7"
|
||||
#define SHAREDIR "share"
|
||||
#define DEFAULT_BASEDIR "C:/Program Files/MySQL/MySQL Server 5.7"
|
||||
#define MYSQL_DATADIR "C:/Program Files/MySQL/MySQL Server 5.7/data"
|
||||
#define MYSQL_KEYRINGDIR "C:/Program Files/MySQL/MySQL Server 5.7/keyring"
|
||||
#define DEFAULT_CHARSET_HOME "C:/Program Files/MySQL/MySQL Server 5.7"
|
||||
#define PLUGINDIR "C:/Program Files/MySQL/MySQL Server 5.7/lib/plugin"
|
||||
/* #undef DEFAULT_SYSCONFDIR */
|
||||
#define DEFAULT_TMPDIR ""
|
||||
#define INSTALL_SBINDIR "/bin"
|
||||
#define INSTALL_BINDIR "/bin"
|
||||
#define INSTALL_MYSQLSHAREDIR "/share"
|
||||
#define INSTALL_SHAREDIR "/share"
|
||||
#define INSTALL_PLUGINDIR "/lib/plugin"
|
||||
#define INSTALL_INCLUDEDIR "/include"
|
||||
#define INSTALL_SCRIPTDIR "/scripts"
|
||||
#define INSTALL_MYSQLDATADIR "/data"
|
||||
#define INSTALL_MYSQLKEYRINGDIR "/keyring"
|
||||
/* #undef INSTALL_PLUGINTESTDIR */
|
||||
#define INSTALL_INFODIR "/docs"
|
||||
#define INSTALL_MYSQLTESTDIR "/mysql-test"
|
||||
#define INSTALL_DOCREADMEDIR "/."
|
||||
#define INSTALL_DOCDIR "/docs"
|
||||
#define INSTALL_MANDIR "/man"
|
||||
#define INSTALL_SUPPORTFILESDIR "/support-files"
|
||||
#define INSTALL_LIBDIR "/lib"
|
||||
|
||||
/*
|
||||
* Readline
|
||||
*/
|
||||
/* #undef HAVE_MBSTATE_T */
|
||||
/* #undef HAVE_LANGINFO_CODESET */
|
||||
/* #undef HAVE_WCSDUP */
|
||||
/* #undef HAVE_WCHAR_T */
|
||||
/* #undef HAVE_WINT_T */
|
||||
/* #undef HAVE_CURSES_H */
|
||||
/* #undef HAVE_NCURSES_H */
|
||||
/* #undef USE_LIBEDIT_INTERFACE */
|
||||
/* #undef HAVE_HIST_ENTRY */
|
||||
/* #undef USE_NEW_EDITLINE_INTERFACE */
|
||||
/* #undef EDITLINE_HAVE_COMPLETION_CHAR */
|
||||
/* #undef EDITLINE_HAVE_COMPLETION_INT */
|
||||
|
||||
/*
|
||||
* Libedit
|
||||
*/
|
||||
/* #undef HAVE_GETLINE */
|
||||
/* #undef HAVE___SECURE_GETENV */
|
||||
/* #undef HAVE_SECURE_GETENV */
|
||||
/* #undef HAVE_VIS */
|
||||
/* #undef HAVE_UNVIS */
|
||||
/* #undef HAVE_GETPW_R_DRAFT */
|
||||
/* #undef HAVE_GETPW_R_POSIX */
|
||||
|
||||
/*
|
||||
* DTrace
|
||||
*/
|
||||
/* #undef HAVE_DTRACE */
|
||||
|
||||
/*
|
||||
* Character sets
|
||||
*/
|
||||
#define MYSQL_DEFAULT_CHARSET_NAME "latin1"
|
||||
#define MYSQL_DEFAULT_COLLATION_NAME "latin1_swedish_ci"
|
||||
#define HAVE_CHARSET_armscii8 1
|
||||
#define HAVE_CHARSET_ascii 1
|
||||
#define HAVE_CHARSET_big5 1
|
||||
#define HAVE_CHARSET_cp1250 1
|
||||
#define HAVE_CHARSET_cp1251 1
|
||||
#define HAVE_CHARSET_cp1256 1
|
||||
#define HAVE_CHARSET_cp1257 1
|
||||
#define HAVE_CHARSET_cp850 1
|
||||
#define HAVE_CHARSET_cp852 1
|
||||
#define HAVE_CHARSET_cp866 1
|
||||
#define HAVE_CHARSET_cp932 1
|
||||
#define HAVE_CHARSET_dec8 1
|
||||
#define HAVE_CHARSET_eucjpms 1
|
||||
#define HAVE_CHARSET_euckr 1
|
||||
#define HAVE_CHARSET_gb2312 1
|
||||
#define HAVE_CHARSET_gbk 1
|
||||
#define HAVE_CHARSET_gb18030 1
|
||||
#define HAVE_CHARSET_geostd8 1
|
||||
#define HAVE_CHARSET_greek 1
|
||||
#define HAVE_CHARSET_hebrew 1
|
||||
#define HAVE_CHARSET_hp8 1
|
||||
#define HAVE_CHARSET_keybcs2 1
|
||||
#define HAVE_CHARSET_koi8r 1
|
||||
#define HAVE_CHARSET_koi8u 1
|
||||
#define HAVE_CHARSET_latin1 1
|
||||
#define HAVE_CHARSET_latin2 1
|
||||
#define HAVE_CHARSET_latin5 1
|
||||
#define HAVE_CHARSET_latin7 1
|
||||
#define HAVE_CHARSET_macce 1
|
||||
#define HAVE_CHARSET_macroman 1
|
||||
#define HAVE_CHARSET_sjis 1
|
||||
#define HAVE_CHARSET_swe7 1
|
||||
#define HAVE_CHARSET_tis620 1
|
||||
#define HAVE_CHARSET_ucs2 1
|
||||
#define HAVE_CHARSET_ujis 1
|
||||
#define HAVE_CHARSET_utf8mb4 1
|
||||
/* #undef HAVE_CHARSET_utf8mb3 */
|
||||
#define HAVE_CHARSET_utf8 1
|
||||
#define HAVE_CHARSET_utf16 1
|
||||
#define HAVE_CHARSET_utf32 1
|
||||
#define HAVE_UCA_COLLATIONS 1
|
||||
|
||||
/*
|
||||
* Feature set
|
||||
*/
|
||||
#define WITH_PARTITION_STORAGE_ENGINE 1
|
||||
|
||||
/*
|
||||
* Performance schema
|
||||
*/
|
||||
#define WITH_PERFSCHEMA_STORAGE_ENGINE 1
|
||||
/* #undef DISABLE_PSI_THREAD */
|
||||
/* #undef DISABLE_PSI_MUTEX */
|
||||
/* #undef DISABLE_PSI_RWLOCK */
|
||||
/* #undef DISABLE_PSI_COND */
|
||||
/* #undef DISABLE_PSI_FILE */
|
||||
/* #undef DISABLE_PSI_TABLE */
|
||||
/* #undef DISABLE_PSI_SOCKET */
|
||||
/* #undef DISABLE_PSI_STAGE */
|
||||
/* #undef DISABLE_PSI_STATEMENT */
|
||||
/* #undef DISABLE_PSI_SP */
|
||||
/* #undef DISABLE_PSI_PS */
|
||||
/* #undef DISABLE_PSI_IDLE */
|
||||
/* #undef DISABLE_PSI_STATEMENT_DIGEST */
|
||||
/* #undef DISABLE_PSI_METADATA */
|
||||
/* #undef DISABLE_PSI_MEMORY */
|
||||
/* #undef DISABLE_PSI_TRANSACTION */
|
||||
|
||||
/*
|
||||
* syscall
|
||||
*/
|
||||
/* #undef HAVE_SYS_THREAD_SELFID */
|
||||
/* #undef HAVE_SYS_GETTID */
|
||||
/* #undef HAVE_PTHREAD_GETTHREADID_NP */
|
||||
/* #undef HAVE_PTHREAD_SETNAME_NP */
|
||||
/* #undef HAVE_INTEGER_PTHREAD_SELF */
|
||||
|
||||
/* Platform-specific C++ compiler behaviors we rely upon */
|
||||
|
||||
/*
|
||||
This macro defines whether the compiler in use needs a 'typename' keyword
|
||||
to access the types defined inside a class template, such types are called
|
||||
dependent types. Some compilers require it, some others forbid it, and some
|
||||
others may work with or without it. For example, GCC requires the 'typename'
|
||||
keyword whenever needing to access a type inside a template, but msvc
|
||||
forbids it.
|
||||
*/
|
||||
#define HAVE_IMPLICIT_DEPENDENT_NAME_TYPING 1
|
||||
|
||||
|
||||
/*
|
||||
* MySQL version
|
||||
*/
|
||||
#define DOT_FRM_VERSION 6
|
||||
#define MYSQL_VERSION_MAJOR 5
|
||||
#define MYSQL_VERSION_MINOR 7
|
||||
#define MYSQL_VERSION_PATCH 39
|
||||
#define MYSQL_VERSION_EXTRA ""
|
||||
#define PACKAGE "mysql"
|
||||
#define PACKAGE_BUGREPORT ""
|
||||
#define PACKAGE_NAME "MySQL Server"
|
||||
#define PACKAGE_STRING "MySQL Server 5.7.39"
|
||||
#define PACKAGE_TARNAME "mysql"
|
||||
#define PACKAGE_VERSION "5.7.39"
|
||||
#define VERSION "5.7.39"
|
||||
#define PROTOCOL_VERSION 10
|
||||
|
||||
/*
|
||||
* CPU info
|
||||
*/
|
||||
#define CPU_LEVEL1_DCACHE_LINESIZE 64
|
||||
|
||||
/*
|
||||
* NDB
|
||||
*/
|
||||
/* #undef WITH_NDBCLUSTER_STORAGE_ENGINE */
|
||||
/* #undef HAVE_PTHREAD_SETSCHEDPARAM */
|
||||
|
||||
/*
|
||||
* Other
|
||||
*/
|
||||
/* #undef EXTRA_DEBUG */
|
||||
/* #undef HAVE_CHOWN */
|
||||
|
||||
/*
|
||||
* Hardcoded values needed by libevent/NDB/memcached
|
||||
*/
|
||||
#define HAVE_FCNTL_H 1
|
||||
#define HAVE_GETADDRINFO 1
|
||||
#define HAVE_INTTYPES_H 1
|
||||
/* libevent's select.c is not Windows compatible */
|
||||
#ifndef _WIN32
|
||||
#define HAVE_SELECT 1
|
||||
#endif
|
||||
#define HAVE_SIGNAL_H 1
|
||||
#define HAVE_STDARG_H 1
|
||||
#define HAVE_STDINT_H 1
|
||||
#define HAVE_STDLIB_H 1
|
||||
#define HAVE_STRDUP 1
|
||||
#define HAVE_STRTOK_R 1
|
||||
#define HAVE_STRTOLL 1
|
||||
#define HAVE_SYS_STAT_H 1
|
||||
#define HAVE_SYS_TYPES_H 1
|
||||
#define SIZEOF_CHAR 1
|
||||
|
||||
/*
|
||||
* Needed by libevent
|
||||
*/
|
||||
/* #undef HAVE_SOCKLEN_T */
|
||||
|
||||
/* For --secure-file-priv */
|
||||
#define DEFAULT_SECURE_FILE_PRIV_DIR "NULL"
|
||||
#define DEFAULT_SECURE_FILE_PRIV_EMBEDDED_DIR "NULL"
|
||||
/* #undef HAVE_LIBNUMA */
|
||||
|
||||
/* For default value of --early_plugin_load */
|
||||
/* #undef DEFAULT_EARLY_PLUGIN_LOAD */
|
||||
|
||||
#endif
|
|
@ -0,0 +1,255 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MY_DBUG_INCLUDED
|
||||
#define MY_DBUG_INCLUDED
|
||||
|
||||
#include "my_global.h" /* MYSQL_PLUGIN_IMPORT */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#if !defined(NDEBUG)
|
||||
|
||||
struct _db_stack_frame_ {
|
||||
const char *func; /* function name of the previous stack frame */
|
||||
const char *file; /* filename of the function of previous frame */
|
||||
uint level; /* this nesting level, highest bit enables tracing */
|
||||
struct _db_stack_frame_ *prev; /* pointer to the previous frame */
|
||||
};
|
||||
|
||||
struct _db_code_state_;
|
||||
extern MYSQL_PLUGIN_IMPORT my_bool _dbug_on_;
|
||||
extern my_bool _db_keyword_(struct _db_code_state_ *, const char *, int);
|
||||
extern int _db_explain_(struct _db_code_state_ *cs, char *buf, size_t len);
|
||||
extern int _db_explain_init_(char *buf, size_t len);
|
||||
extern int _db_is_pushed_(void);
|
||||
extern void _db_setjmp_(void);
|
||||
extern void _db_longjmp_(void);
|
||||
extern void _db_process_(const char *name);
|
||||
extern void _db_push_(const char *control);
|
||||
extern void _db_pop_(void);
|
||||
extern void _db_set_(const char *control);
|
||||
extern void _db_set_init_(const char *control);
|
||||
extern void _db_enter_(const char *_func_, const char *_file_, uint _line_,
|
||||
struct _db_stack_frame_ *_stack_frame_);
|
||||
extern void _db_return_(uint _line_, struct _db_stack_frame_ *_stack_frame_);
|
||||
extern void _db_pargs_(uint _line_,const char *keyword);
|
||||
extern int _db_enabled_();
|
||||
extern void _db_doprnt_(const char *format,...)
|
||||
MY_ATTRIBUTE((format(printf, 1, 2)));
|
||||
extern void _db_doputs_(const char *log);
|
||||
extern void _db_dump_(uint _line_,const char *keyword,
|
||||
const unsigned char *memory, size_t length);
|
||||
extern void _db_end_(void);
|
||||
extern void _db_lock_file_(void);
|
||||
extern void _db_unlock_file_(void);
|
||||
extern FILE *_db_fp_(void);
|
||||
extern void _db_flush_();
|
||||
extern const char* _db_get_func_(void);
|
||||
|
||||
#define DBUG_ENTER(a) struct _db_stack_frame_ _db_stack_frame_; \
|
||||
_db_enter_ (a,__FILE__,__LINE__,&_db_stack_frame_)
|
||||
#define DBUG_LEAVE _db_return_ (__LINE__, &_db_stack_frame_)
|
||||
#define DBUG_RETURN(a1) do {DBUG_LEAVE; return(a1);} while(0)
|
||||
#define DBUG_VOID_RETURN do {DBUG_LEAVE; return;} while(0)
|
||||
#define DBUG_EXECUTE(keyword,a1) \
|
||||
do {if (_db_keyword_(0, (keyword), 0)) { a1 }} while(0)
|
||||
#define DBUG_EXECUTE_IF(keyword,a1) \
|
||||
do {if (_db_keyword_(0, (keyword), 1)) { a1 }} while(0)
|
||||
#define DBUG_EVALUATE(keyword,a1,a2) \
|
||||
(_db_keyword_(0,(keyword), 0) ? (a1) : (a2))
|
||||
#define DBUG_EVALUATE_IF(keyword,a1,a2) \
|
||||
(_db_keyword_(0,(keyword), 1) ? (a1) : (a2))
|
||||
#define DBUG_PRINT(keyword,arglist) \
|
||||
do \
|
||||
{ \
|
||||
if (_dbug_on_) \
|
||||
{ \
|
||||
_db_pargs_(__LINE__,keyword); \
|
||||
if (_db_enabled_()) \
|
||||
{ \
|
||||
_db_doprnt_ arglist; \
|
||||
} \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
/*
|
||||
An alternate to DBUG_PRINT() macro, which takes a single string
|
||||
as the second argument.
|
||||
*/
|
||||
#define DBUG_PUTS(keyword,arg) \
|
||||
do \
|
||||
{ \
|
||||
if (_dbug_on_) \
|
||||
{ \
|
||||
_db_pargs_(__LINE__,keyword); \
|
||||
if (_db_enabled_()) \
|
||||
{ \
|
||||
_db_doputs_(arg); \
|
||||
} \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
#define DBUG_PUSH(a1) _db_push_ (a1)
|
||||
#define DBUG_POP() _db_pop_ ()
|
||||
#define DBUG_SET(a1) _db_set_ (a1)
|
||||
#define DBUG_SET_INITIAL(a1) _db_set_init_ (a1)
|
||||
#define DBUG_PROCESS(a1) _db_process_(a1)
|
||||
#define DBUG_FILE _db_fp_()
|
||||
#define DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1))
|
||||
#define DBUG_LONGJMP(a1,a2) (_db_longjmp_ (), longjmp (a1, a2))
|
||||
#define DBUG_DUMP(keyword,a1,a2) _db_dump_(__LINE__,keyword,a1,a2)
|
||||
#define DBUG_END() _db_end_ ()
|
||||
#define DBUG_LOCK_FILE _db_lock_file_()
|
||||
#define DBUG_UNLOCK_FILE _db_unlock_file_()
|
||||
#define DBUG_EXPLAIN(buf,len) _db_explain_(0, (buf),(len))
|
||||
#define DBUG_EXPLAIN_INITIAL(buf,len) _db_explain_init_((buf),(len))
|
||||
#define DEBUGGER_OFF do { _dbug_on_= 0; } while(0)
|
||||
#define DEBUGGER_ON do { _dbug_on_= 1; } while(0)
|
||||
#ifndef _WIN32
|
||||
#define DBUG_ABORT() (_db_flush_(), abort())
|
||||
#else
|
||||
/*
|
||||
Avoid popup with abort/retry/ignore buttons. When BUG#31745 is fixed we can
|
||||
call abort() instead of _exit(2) (now it would cause a "test signal" popup).
|
||||
*/
|
||||
#include <crtdbg.h>
|
||||
#define DBUG_ABORT() (_db_flush_(),\
|
||||
(void)_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE),\
|
||||
(void)_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR),\
|
||||
_exit(2))
|
||||
#endif
|
||||
#define DBUG_CHECK_CRASH(func, op) \
|
||||
do { char _dbuf_[255]; strxnmov(_dbuf_, sizeof(_dbuf_)-1, (func), (op)); \
|
||||
DBUG_EXECUTE_IF(_dbuf_, DBUG_ABORT()); } while(0)
|
||||
#define DBUG_CRASH_ENTER(func) \
|
||||
DBUG_ENTER(func); DBUG_CHECK_CRASH(func, "_crash_enter")
|
||||
#define DBUG_CRASH_RETURN(val) \
|
||||
DBUG_CHECK_CRASH(_db_get_func_(), "_crash_return")
|
||||
#define DBUG_CRASH_VOID_RETURN \
|
||||
DBUG_CHECK_CRASH (_db_get_func_(), "_crash_return")
|
||||
|
||||
/*
|
||||
Make the program fail, without creating a core file.
|
||||
abort() will send SIGABRT which (most likely) generates core.
|
||||
Use SIGKILL instead, which cannot be caught.
|
||||
We also pause the current thread, until the signal is actually delivered.
|
||||
An alternative would be to use _exit(EXIT_FAILURE),
|
||||
but then valgrind would report lots of memory leaks.
|
||||
*/
|
||||
#ifdef _WIN32
|
||||
#define DBUG_SUICIDE() DBUG_ABORT()
|
||||
#else
|
||||
extern void _db_suicide_();
|
||||
extern void _db_flush_gcov_();
|
||||
#define DBUG_SUICIDE() (_db_flush_(), _db_suicide_())
|
||||
#endif
|
||||
|
||||
#else /* No debugger */
|
||||
|
||||
#define DBUG_ENTER(a1)
|
||||
#define DBUG_LEAVE
|
||||
#define DBUG_RETURN(a1) do { return(a1); } while(0)
|
||||
#define DBUG_VOID_RETURN do { return; } while(0)
|
||||
#define DBUG_EXECUTE(keyword,a1) do { } while(0)
|
||||
#define DBUG_EXECUTE_IF(keyword,a1) do { } while(0)
|
||||
#define DBUG_EVALUATE(keyword,a1,a2) (a2)
|
||||
#define DBUG_EVALUATE_IF(keyword,a1,a2) (a2)
|
||||
#define DBUG_PRINT(keyword,arglist) do { } while(0)
|
||||
#define DBUG_PUTS(keyword,arg) do { } while(0)
|
||||
#define DBUG_LOG(keyword,arglist) do { } while(0)
|
||||
#define DBUG_PUSH(a1) do { } while(0)
|
||||
#define DBUG_SET(a1) do { } while(0)
|
||||
#define DBUG_SET_INITIAL(a1) do { } while(0)
|
||||
#define DBUG_POP() do { } while(0)
|
||||
#define DBUG_PROCESS(a1) do { } while(0)
|
||||
#define DBUG_SETJMP(a1) setjmp(a1)
|
||||
#define DBUG_LONGJMP(a1) longjmp(a1)
|
||||
#define DBUG_DUMP(keyword,a1,a2) do { } while(0)
|
||||
#define DBUG_END() do { } while(0)
|
||||
#define DBUG_LOCK_FILE do { } while(0)
|
||||
#define DBUG_FILE (stderr)
|
||||
#define DBUG_UNLOCK_FILE do { } while(0)
|
||||
#define DBUG_EXPLAIN(buf,len)
|
||||
#define DBUG_EXPLAIN_INITIAL(buf,len)
|
||||
#define DEBUGGER_OFF do { } while(0)
|
||||
#define DEBUGGER_ON do { } while(0)
|
||||
#define DBUG_ABORT() do { } while(0)
|
||||
#define DBUG_CRASH_ENTER(func)
|
||||
#define DBUG_CRASH_RETURN(val) do { return(val); } while(0)
|
||||
#define DBUG_CRASH_VOID_RETURN do { return; } while(0)
|
||||
#define DBUG_SUICIDE() do { } while(0)
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef EXTRA_DEBUG
|
||||
/**
|
||||
Sync points allow us to force the server to reach a certain line of code
|
||||
and block there until the client tells the server it is ok to go on.
|
||||
The client tells the server to block with SELECT GET_LOCK()
|
||||
and unblocks it with SELECT RELEASE_LOCK(). Used for debugging difficult
|
||||
concurrency problems
|
||||
*/
|
||||
#define DBUG_SYNC_POINT(lock_name,lock_timeout) \
|
||||
debug_sync_point(lock_name,lock_timeout)
|
||||
void debug_sync_point(const char* lock_name, uint lock_timeout);
|
||||
#else
|
||||
#define DBUG_SYNC_POINT(lock_name,lock_timeout)
|
||||
#endif /* EXTRA_DEBUG */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if !defined(NDEBUG)
|
||||
#include <sstream>
|
||||
|
||||
/*
|
||||
A C++ interface to the DBUG_PUTS macro. The DBUG_LOG macro also
|
||||
takes two arguments. The first argument is the keyword, as that of the
|
||||
DBUG_PRINT. The 2nd argument 'v' will be passed to a C++ output stream.
|
||||
This enables the use of C++ style output stream operator. In the code, it
|
||||
will be used as follows:
|
||||
|
||||
DBUG_LOG("blob", "space: " << space_id);
|
||||
|
||||
Note: DBUG_PRINT() has a limitation of 1024 bytes for a single
|
||||
print out. This limitation is not there for DBUG_PUTS and DBUG_LOG
|
||||
macros.
|
||||
*/
|
||||
|
||||
#define DBUG_LOG(keyword, v) do { \
|
||||
std::ostringstream sout; \
|
||||
sout << v; \
|
||||
DBUG_PUTS(keyword, sout.str().c_str()); \
|
||||
} while(0)
|
||||
#endif /* NDEBUG */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* MY_DBUG_INCLUDED */
|
|
@ -0,0 +1,100 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MY_DIR_H
|
||||
#define MY_DIR_H
|
||||
|
||||
#include "my_global.h"
|
||||
|
||||
#include <sys/stat.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Defines for my_dir and my_stat */
|
||||
|
||||
#ifdef _WIN32
|
||||
#define S_IROTH _S_IREAD
|
||||
#define S_IFIFO _S_IFIFO
|
||||
#endif
|
||||
|
||||
#define MY_S_IFMT S_IFMT /* type of file */
|
||||
#define MY_S_IFDIR S_IFDIR /* directory */
|
||||
#define MY_S_IFCHR S_IFCHR /* character special */
|
||||
#define MY_S_IFBLK S_IFBLK /* block special */
|
||||
#define MY_S_IFREG S_IFREG /* regular */
|
||||
#define MY_S_IFIFO S_IFIFO /* fifo */
|
||||
#define MY_S_ISUID S_ISUID /* set user id on execution */
|
||||
#define MY_S_ISGID S_ISGID /* set group id on execution */
|
||||
#define MY_S_ISVTX S_ISVTX /* save swapped text even after use */
|
||||
#define MY_S_IREAD S_IREAD /* read permission, owner */
|
||||
#define MY_S_IWRITE S_IWRITE /* write permission, owner */
|
||||
#define MY_S_IEXEC S_IEXEC /* execute/search permission, owner */
|
||||
|
||||
#define MY_S_ISDIR(m) (((m) & MY_S_IFMT) == MY_S_IFDIR)
|
||||
#define MY_S_ISCHR(m) (((m) & MY_S_IFMT) == MY_S_IFCHR)
|
||||
#define MY_S_ISBLK(m) (((m) & MY_S_IFMT) == MY_S_IFBLK)
|
||||
#define MY_S_ISREG(m) (((m) & MY_S_IFMT) == MY_S_IFREG)
|
||||
#define MY_S_ISFIFO(m) (((m) & MY_S_IFMT) == MY_S_IFIFO)
|
||||
|
||||
#define MY_DONT_SORT 512 /* my_lib; Don't sort files */
|
||||
#define MY_WANT_STAT 1024 /* my_lib; stat files */
|
||||
|
||||
/* typedefs for my_dir & my_stat */
|
||||
|
||||
#if(_MSC_VER)
|
||||
#define MY_STAT struct _stati64 /* 64 bit file size */
|
||||
#else
|
||||
#define MY_STAT struct stat /* Orginal struct have what we need */
|
||||
#endif
|
||||
|
||||
/* Struct describing one file returned from my_dir */
|
||||
typedef struct fileinfo
|
||||
{
|
||||
char *name;
|
||||
MY_STAT *mystat;
|
||||
} FILEINFO;
|
||||
|
||||
typedef struct st_my_dir /* Struct returned from my_dir */
|
||||
{
|
||||
/*
|
||||
These members are just copies of parts of DYNAMIC_ARRAY structure,
|
||||
which is allocated right after the end of MY_DIR structure (MEM_ROOT
|
||||
for storing names is also resides there). We've left them here because
|
||||
we don't want to change code that uses my_dir.
|
||||
*/
|
||||
struct fileinfo *dir_entry;
|
||||
uint number_off_files;
|
||||
} MY_DIR;
|
||||
|
||||
extern MY_DIR *my_dir(const char *path,myf MyFlags);
|
||||
extern void my_dirend(MY_DIR *buffer);
|
||||
extern MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags);
|
||||
extern int my_fstat(int filenr, MY_STAT *stat_area, myf MyFlags);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MY_DIR_H */
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
Copyright (c) 2002, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef _my_getopt_h
|
||||
#define _my_getopt_h
|
||||
|
||||
#include "my_sys.h" /* loglevel */
|
||||
|
||||
C_MODE_START
|
||||
|
||||
#define GET_NO_ARG 1
|
||||
#define GET_BOOL 2
|
||||
#define GET_INT 3
|
||||
#define GET_UINT 4
|
||||
#define GET_LONG 5
|
||||
#define GET_ULONG 6
|
||||
#define GET_LL 7
|
||||
#define GET_ULL 8
|
||||
#define GET_STR 9
|
||||
#define GET_STR_ALLOC 10
|
||||
#define GET_DISABLED 11
|
||||
#define GET_ENUM 12
|
||||
#define GET_SET 13
|
||||
#define GET_DOUBLE 14
|
||||
#define GET_FLAGSET 15
|
||||
#define GET_PASSWORD 16
|
||||
|
||||
#if SIZEOF_INT == 4
|
||||
#define GET_INT32 GET_INT
|
||||
#define GET_UINT32 GET_UINT
|
||||
#elif SIZEOF_LONG == 4
|
||||
#define GET_INT32 GET_LONG
|
||||
#define GET_UINT32 GET_ULONG
|
||||
#else
|
||||
#error Neither int or long is of 4 bytes width
|
||||
#endif
|
||||
|
||||
#define GET_ASK_ADDR 128
|
||||
#define GET_TYPE_MASK 127
|
||||
|
||||
/**
|
||||
Enumeration of the my_option::arg_type attributes.
|
||||
It should be noted that for historical reasons variables with the combination
|
||||
arg_type=NO_ARG, my_option::var_type=GET_BOOL still accepts
|
||||
arguments. This is someone counter intuitive and care should be taken
|
||||
if the code is refactored.
|
||||
*/
|
||||
enum get_opt_arg_type { NO_ARG, OPT_ARG, REQUIRED_ARG };
|
||||
|
||||
struct st_typelib;
|
||||
|
||||
struct my_option
|
||||
{
|
||||
const char *name; /**< Name of the option. name=NULL
|
||||
marks the end of the my_option[]
|
||||
array.
|
||||
*/
|
||||
int id; /**< For 0<id<=255 it's means one
|
||||
character for a short option
|
||||
(like -A), if >255 no short option
|
||||
is created, but a long option still
|
||||
can be identified uniquely in the
|
||||
my_get_one_option() callback.
|
||||
If an opton needs neither special
|
||||
treatment in the my_get_one_option()
|
||||
nor one-letter short equivalent
|
||||
use id=0.
|
||||
id=-1 is a special case and is used
|
||||
to generate deprecation warnings for
|
||||
plugin options. It should not be
|
||||
used for anything else.
|
||||
*/
|
||||
const char *comment; /**< option comment, for autom. --help.
|
||||
if it's NULL the option is not
|
||||
visible in --help.
|
||||
*/
|
||||
void *value; /**< A pointer to the variable value */
|
||||
void *u_max_value; /**< The user def. max variable value */
|
||||
struct st_typelib *typelib; /**< Pointer to possible values */
|
||||
ulong var_type; /**< GET_BOOL, GET_ULL, etc */
|
||||
enum get_opt_arg_type arg_type; /**< e.g. REQUIRED_ARG or OPT_ARG */
|
||||
longlong def_value; /**< Default value */
|
||||
longlong min_value; /**< Min allowed value (for numbers) */
|
||||
ulonglong max_value; /**< Max allowed value (for numbers) */
|
||||
longlong sub_size; /**< Unused */
|
||||
long block_size; /**< Value should be a mult. of this (for numbers) */
|
||||
void *app_type; /**< To be used by an application */
|
||||
};
|
||||
|
||||
|
||||
typedef my_bool (*my_get_one_option)(int, const struct my_option *, char *);
|
||||
/**
|
||||
Used to retrieve a reference to the object (variable) that holds the value
|
||||
for the given option. For example, if var_type is GET_UINT, the function
|
||||
must return a pointer to a variable of type uint. A argument is stored in
|
||||
the location pointed to by the returned pointer.
|
||||
*/
|
||||
typedef void *(*my_getopt_value)(const char *, size_t, const struct my_option *,
|
||||
int *);
|
||||
|
||||
|
||||
extern char *disabled_my_option;
|
||||
extern my_bool my_getopt_print_errors;
|
||||
extern my_bool my_getopt_skip_unknown;
|
||||
extern my_error_reporter my_getopt_error_reporter;
|
||||
|
||||
extern int handle_options (int *argc, char ***argv,
|
||||
const struct my_option *longopts, my_get_one_option);
|
||||
extern int my_handle_options (int *argc, char ***argv,
|
||||
const struct my_option *longopts,
|
||||
my_get_one_option,
|
||||
const char **command_list, my_bool ignore_unknown_option);
|
||||
extern void print_cmdline_password_warning();
|
||||
extern void my_cleanup_options(const struct my_option *options);
|
||||
extern void my_cleanup_options(const struct my_option *options);
|
||||
extern void my_print_help(const struct my_option *options);
|
||||
extern void my_print_variables(const struct my_option *options);
|
||||
extern void my_print_variables_ex(const struct my_option *options, FILE* file);
|
||||
extern void my_getopt_register_get_addr(my_getopt_value);
|
||||
|
||||
ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
|
||||
my_bool *fix);
|
||||
longlong getopt_ll_limit_value(longlong, const struct my_option *,
|
||||
my_bool *fix);
|
||||
double getopt_double_limit_value(double num, const struct my_option *optp,
|
||||
my_bool *fix);
|
||||
my_bool getopt_compare_strings(const char *s, const char *t, uint length);
|
||||
ulonglong max_of_int_range(int var_type);
|
||||
|
||||
ulonglong getopt_double2ulonglong(double);
|
||||
double getopt_ulonglong2double(ulonglong);
|
||||
|
||||
C_MODE_END
|
||||
|
||||
#endif /* _my_getopt_h */
|
||||
|
|
@ -0,0 +1,804 @@
|
|||
/*
|
||||
Copyright (c) 2001, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MY_GLOBAL_INCLUDED
|
||||
#define MY_GLOBAL_INCLUDED
|
||||
|
||||
/*
|
||||
This include file should be included first in every header file.
|
||||
|
||||
This makes sure my_config.h is included to get platform specific
|
||||
symbols defined and it makes sure a lot of platform/compiler
|
||||
differences are mitigated.
|
||||
*/
|
||||
|
||||
#include "my_config.h"
|
||||
|
||||
#define __STDC_LIMIT_MACROS /* Enable C99 limit macros */
|
||||
#define __STDC_FORMAT_MACROS /* Enable C99 printf format macros */
|
||||
#define _USE_MATH_DEFINES /* Get access to M_PI, M_E, etc. in math.h */
|
||||
|
||||
#ifdef _WIN32
|
||||
/* Include common headers.*/
|
||||
# include <winsock2.h>
|
||||
# include <ws2tcpip.h> /* SOCKET */
|
||||
# include <io.h> /* access(), chmod() */
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#include <stddef.h>
|
||||
#include <math.h>
|
||||
#include <limits.h>
|
||||
#include <float.h>
|
||||
#include <fcntl.h>
|
||||
#include <time.h>
|
||||
#include <errno.h> /* Recommended by debian */
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifdef HAVE_SYS_SOCKET_H
|
||||
#include <sys/socket.h>
|
||||
#endif
|
||||
#if !defined(_WIN32)
|
||||
#include <netdb.h>
|
||||
#endif
|
||||
#ifdef MY_MSCRT_DEBUG
|
||||
#include <crtdbg.h>
|
||||
#endif
|
||||
|
||||
/*
|
||||
A lot of our programs uses asserts, so better to always include it
|
||||
This also fixes a problem when people uses assert without including
|
||||
assert.h
|
||||
*/
|
||||
#include <assert.h>
|
||||
|
||||
/* Include standard definitions of operator new and delete. */
|
||||
#ifdef __cplusplus
|
||||
# include <new>
|
||||
#endif
|
||||
|
||||
#include "my_compiler.h"
|
||||
|
||||
|
||||
/*
|
||||
InnoDB depends on some MySQL internals which other plugins should not
|
||||
need. This is because of InnoDB's foreign key support, "safe" binlog
|
||||
truncation, and other similar legacy features.
|
||||
|
||||
We define accessors for these internals unconditionally, but do not
|
||||
expose them in mysql/plugin.h. They are declared in ha_innodb.h for
|
||||
InnoDB's use.
|
||||
*/
|
||||
#define INNODB_COMPATIBILITY_HOOKS
|
||||
|
||||
/* Macros to make switching between C and C++ mode easier */
|
||||
#ifdef __cplusplus
|
||||
#define C_MODE_START extern "C" {
|
||||
#define C_MODE_END }
|
||||
#else
|
||||
#define C_MODE_START
|
||||
#define C_MODE_END
|
||||
#endif
|
||||
|
||||
#ifdef WITH_PERFSCHEMA_STORAGE_ENGINE
|
||||
#define HAVE_PSI_INTERFACE
|
||||
#endif /* WITH_PERFSCHEMA_STORAGE_ENGINE */
|
||||
|
||||
/* Make it easier to add conditional code in _expressions_ */
|
||||
#ifdef _WIN32
|
||||
#define IF_WIN(A,B) A
|
||||
#else
|
||||
#define IF_WIN(A,B) B
|
||||
#endif
|
||||
|
||||
#if defined (_WIN32)
|
||||
/*
|
||||
off_t is 32 bit long. We do not use C runtime functions
|
||||
with off_t but native Win32 file IO APIs, that work with
|
||||
64 bit offsets.
|
||||
*/
|
||||
#undef SIZEOF_OFF_T
|
||||
#define SIZEOF_OFF_T 8
|
||||
|
||||
static inline void sleep(unsigned long seconds)
|
||||
{
|
||||
Sleep(seconds * 1000);
|
||||
}
|
||||
|
||||
/* Define missing access() modes. */
|
||||
#define F_OK 0
|
||||
#define W_OK 2
|
||||
#define R_OK 4 /* Test for read permission. */
|
||||
|
||||
/* Define missing file locking constants. */
|
||||
#define F_RDLCK 1
|
||||
#define F_WRLCK 2
|
||||
#define F_UNLCK 3
|
||||
#define F_TO_EOF 0x3FFFFFFF
|
||||
|
||||
#define O_NONBLOCK 1 /* For emulation of fcntl() */
|
||||
|
||||
/*
|
||||
SHUT_RDWR is called SD_BOTH in windows and
|
||||
is defined to 2 in winsock2.h
|
||||
#define SD_BOTH 0x02
|
||||
*/
|
||||
#define SHUT_RDWR 0x02
|
||||
|
||||
/* Shared memory and named pipe connections are supported. */
|
||||
#define shared_memory_buffer_length 16000
|
||||
#define default_shared_memory_base_name "MYSQL"
|
||||
#endif /* _WIN32*/
|
||||
|
||||
/**
|
||||
Cast a member of a structure to the structure that contains it.
|
||||
|
||||
@param ptr Pointer to the member.
|
||||
@param type Type of the structure that contains the member.
|
||||
@param member Name of the member within the structure.
|
||||
*/
|
||||
#define my_container_of(ptr, type, member) \
|
||||
((type *)((char *)ptr - offsetof(type, member)))
|
||||
|
||||
/* an assert that works at compile-time. only for constant expression */
|
||||
#define compile_time_assert(X) \
|
||||
do \
|
||||
{ \
|
||||
typedef char compile_time_assert[(X) ? 1 : -1] MY_ATTRIBUTE((unused)); \
|
||||
} while(0)
|
||||
|
||||
#define QUOTE_ARG(x) #x /* Quote argument (before cpp) */
|
||||
#define STRINGIFY_ARG(x) QUOTE_ARG(x) /* Quote argument, after cpp */
|
||||
|
||||
#ifdef _WIN32
|
||||
#define SO_EXT ".dll"
|
||||
#elif defined(__APPLE__)
|
||||
#define SO_EXT ".dylib"
|
||||
#else
|
||||
#define SO_EXT ".so"
|
||||
#endif
|
||||
|
||||
#if !defined(HAVE_UINT)
|
||||
typedef unsigned int uint;
|
||||
typedef unsigned short ushort;
|
||||
#endif
|
||||
|
||||
#define swap_variables(t, a, b) { t dummy; dummy= a; a= b; b= dummy; }
|
||||
#define MY_TEST(a) ((a) ? 1 : 0)
|
||||
#define set_if_bigger(a,b) do { if ((a) < (b)) (a)=(b); } while(0)
|
||||
#define set_if_smaller(a,b) do { if ((a) > (b)) (a)=(b); } while(0)
|
||||
#define test_all_bits(a,b) (((a) & (b)) == (b))
|
||||
#define array_elements(A) ((uint) (sizeof(A)/sizeof(A[0])))
|
||||
|
||||
/* Define some general constants */
|
||||
#ifndef TRUE
|
||||
#define TRUE (1) /* Logical true */
|
||||
#define FALSE (0) /* Logical false */
|
||||
#endif
|
||||
|
||||
/* Some types that is different between systems */
|
||||
|
||||
typedef int File; /* File descriptor */
|
||||
#ifdef _WIN32
|
||||
typedef SOCKET my_socket;
|
||||
#else
|
||||
typedef int my_socket; /* File descriptor for sockets */
|
||||
#define INVALID_SOCKET -1
|
||||
#endif
|
||||
C_MODE_START
|
||||
typedef void (*sig_return)();/* Returns type from signal */
|
||||
C_MODE_END
|
||||
#if defined(__GNUC__)
|
||||
typedef char pchar; /* Mixed prototypes can take char */
|
||||
typedef char pbool; /* Mixed prototypes can take char */
|
||||
#else
|
||||
typedef int pchar; /* Mixed prototypes can't take char */
|
||||
typedef int pbool; /* Mixed prototypes can't take char */
|
||||
#endif
|
||||
C_MODE_START
|
||||
typedef int (*qsort_cmp)(const void *,const void *);
|
||||
typedef int (*qsort_cmp2)(const void*, const void *,const void *);
|
||||
C_MODE_END
|
||||
#ifdef _WIN32
|
||||
typedef int socket_len_t;
|
||||
typedef int sigset_t;
|
||||
typedef int mode_t;
|
||||
typedef SSIZE_T ssize_t;
|
||||
#else
|
||||
typedef socklen_t socket_len_t;
|
||||
#endif
|
||||
typedef socket_len_t SOCKET_SIZE_TYPE; /* Used by NDB */
|
||||
|
||||
/* file create flags */
|
||||
|
||||
#ifndef O_SHARE /* Probably not windows */
|
||||
#define O_SHARE 0 /* Flag to my_open for shared files */
|
||||
#ifndef O_BINARY
|
||||
#define O_BINARY 0 /* Flag to my_open for binary files */
|
||||
#endif
|
||||
#ifndef FILE_BINARY
|
||||
#define FILE_BINARY O_BINARY /* Flag to my_fopen for binary streams */
|
||||
#endif
|
||||
#ifdef HAVE_FCNTL
|
||||
#define HAVE_FCNTL_LOCK
|
||||
#define F_TO_EOF 0L /* Param to lockf() to lock rest of file */
|
||||
#endif
|
||||
#endif /* O_SHARE */
|
||||
|
||||
#ifndef O_TEMPORARY
|
||||
#define O_TEMPORARY 0
|
||||
#endif
|
||||
#ifndef O_SHORT_LIVED
|
||||
#define O_SHORT_LIVED 0
|
||||
#endif
|
||||
#ifndef O_NOFOLLOW
|
||||
#define O_NOFOLLOW 0
|
||||
#endif
|
||||
|
||||
/* additional file share flags for win32 */
|
||||
#ifdef _WIN32
|
||||
#define _SH_DENYRWD 0x110 /* deny read/write mode & delete */
|
||||
#define _SH_DENYWRD 0x120 /* deny write mode & delete */
|
||||
#define _SH_DENYRDD 0x130 /* deny read mode & delete */
|
||||
#define _SH_DENYDEL 0x140 /* deny delete only */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
|
||||
/* General constants */
|
||||
#define FN_LEN 256 /* Max file name len */
|
||||
#define FN_HEADLEN 253 /* Max length of filepart of file name */
|
||||
#define FN_EXTLEN 20 /* Max length of extension (part of FN_LEN) */
|
||||
#define FN_REFLEN 512 /* Max length of full path-name */
|
||||
#define FN_REFLEN_SE 4000 /* Max length of full path-name in SE */
|
||||
#define FN_EXTCHAR '.'
|
||||
#define FN_HOMELIB '~' /* ~/ is used as abbrev for home dir */
|
||||
#define FN_CURLIB '.' /* ./ is used as abbrev for current dir */
|
||||
#define FN_PARENTDIR ".." /* Parent directory; Must be a string */
|
||||
|
||||
#ifdef _WIN32
|
||||
#define FN_LIBCHAR '\\'
|
||||
#define FN_LIBCHAR2 '/'
|
||||
#define FN_DIRSEP "/\\" /* Valid directory separators */
|
||||
#define FN_EXEEXT ".exe"
|
||||
#define FN_SOEXT ".dll"
|
||||
#define FN_ROOTDIR "\\"
|
||||
#define FN_DEVCHAR ':'
|
||||
#define FN_NETWORK_DRIVES /* Uses \\ to indicate network drives */
|
||||
#else
|
||||
#define FN_LIBCHAR '/'
|
||||
/*
|
||||
FN_LIBCHAR2 is not defined on !Windows. Use is_directory_separator().
|
||||
*/
|
||||
#define FN_DIRSEP "/" /* Valid directory separators */
|
||||
#define FN_EXEEXT ""
|
||||
#define FN_SOEXT ".so"
|
||||
#define FN_ROOTDIR "/"
|
||||
#endif
|
||||
|
||||
static inline int is_directory_separator(char c)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return c == FN_LIBCHAR || c == FN_LIBCHAR2;
|
||||
#else
|
||||
return c == FN_LIBCHAR;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
MY_FILE_MIN is Windows speciality and is used to quickly detect
|
||||
the mismatch of CRT and mysys file IO usage on Windows at runtime.
|
||||
CRT file descriptors can be in the range 0-2047, whereas descriptors returned
|
||||
by my_open() will start with 2048. If a file descriptor with value less then
|
||||
MY_FILE_MIN is passed to mysys IO function, chances are it stemms from
|
||||
open()/fileno() and not my_open()/my_fileno.
|
||||
|
||||
For Posix, mysys functions are light wrappers around libc, and MY_FILE_MIN
|
||||
is logically 0.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
#define MY_FILE_MIN 2048
|
||||
#else
|
||||
#define MY_FILE_MIN 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
MY_NFILE is the default size of my_file_info array.
|
||||
|
||||
It is larger on Windows, because it all file handles are stored in my_file_info
|
||||
Default size is 16384 and this should be enough for most cases.If it is not
|
||||
enough, --max-open-files with larger value can be used.
|
||||
|
||||
For Posix , my_file_info array is only used to store filenames for
|
||||
error reporting and its size is not a limitation for number of open files.
|
||||
*/
|
||||
#ifdef _WIN32
|
||||
#define MY_NFILE (16384 + MY_FILE_MIN)
|
||||
#else
|
||||
#define MY_NFILE 64
|
||||
#endif
|
||||
|
||||
#define OS_FILE_LIMIT UINT_MAX
|
||||
|
||||
/*
|
||||
Io buffer size; Must be a power of 2 and a multiple of 512. May be
|
||||
smaller what the disk page size. This influences the speed of the
|
||||
isam btree library. eg to big to slow.
|
||||
*/
|
||||
#define IO_SIZE 4096
|
||||
/*
|
||||
How much overhead does malloc have. The code often allocates
|
||||
something like 1024-MALLOC_OVERHEAD bytes
|
||||
*/
|
||||
#define MALLOC_OVERHEAD 8
|
||||
|
||||
/* get memory in huncs */
|
||||
#define ONCE_ALLOC_INIT (uint) (4096-MALLOC_OVERHEAD)
|
||||
/* Typical record cash */
|
||||
#define RECORD_CACHE_SIZE (uint) (64*1024-MALLOC_OVERHEAD)
|
||||
/* Typical key cash */
|
||||
#define KEY_CACHE_SIZE (uint) (8*1024*1024)
|
||||
/* Default size of a key cache block */
|
||||
#define KEY_CACHE_BLOCK_SIZE (uint) 1024
|
||||
|
||||
|
||||
/* Some defines of functions for portability */
|
||||
|
||||
#if (_WIN32)
|
||||
#if !defined(_WIN64)
|
||||
inline double my_ulonglong2double(unsigned long long value)
|
||||
{
|
||||
long long nr=(long long) value;
|
||||
if (nr >= 0)
|
||||
return (double) nr;
|
||||
return (18446744073709551616.0 + (double) nr);
|
||||
}
|
||||
#define ulonglong2double my_ulonglong2double
|
||||
#define my_off_t2double my_ulonglong2double
|
||||
#endif /* _WIN64 */
|
||||
inline unsigned long long my_double2ulonglong(double d)
|
||||
{
|
||||
double t= d - (double) 0x8000000000000000ULL;
|
||||
|
||||
if (t >= 0)
|
||||
return ((unsigned long long) t) + 0x8000000000000000ULL;
|
||||
return (unsigned long long) d;
|
||||
}
|
||||
#define double2ulonglong my_double2ulonglong
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifndef ulonglong2double
|
||||
#define ulonglong2double(A) ((double) (ulonglong) (A))
|
||||
#define my_off_t2double(A) ((double) (my_off_t) (A))
|
||||
#endif
|
||||
#ifndef double2ulonglong
|
||||
#define double2ulonglong(A) ((ulonglong) (double) (A))
|
||||
#endif
|
||||
|
||||
#define INT_MIN64 (~0x7FFFFFFFFFFFFFFFLL)
|
||||
#define INT_MAX64 0x7FFFFFFFFFFFFFFFLL
|
||||
#define INT_MIN32 (~0x7FFFFFFFL)
|
||||
#define INT_MAX32 0x7FFFFFFFL
|
||||
#define UINT_MAX32 0xFFFFFFFFL
|
||||
#define INT_MIN24 (~0x007FFFFF)
|
||||
#define INT_MAX24 0x007FFFFF
|
||||
#define UINT_MAX24 0x00FFFFFF
|
||||
#define INT_MIN16 (~0x7FFF)
|
||||
#define INT_MAX16 0x7FFF
|
||||
#define UINT_MAX16 0xFFFF
|
||||
#define INT_MIN8 (~0x7F)
|
||||
#define INT_MAX8 0x7F
|
||||
#define UINT_MAX8 0xFF
|
||||
|
||||
#ifndef SIZE_T_MAX
|
||||
#define SIZE_T_MAX (~((size_t) 0))
|
||||
#endif
|
||||
|
||||
// Our ifdef trickery for my_isfinite does not work with gcc/solaris unless we:
|
||||
#ifdef HAVE_IEEEFP_H
|
||||
#include <ieeefp.h>
|
||||
#endif
|
||||
|
||||
#if (__cplusplus >= 201103L)
|
||||
/* For C++11 use the new std functions rather than C99 macros. */
|
||||
#include <cmath>
|
||||
#define my_isfinite(X) std::isfinite(X)
|
||||
#define my_isnan(X) std::isnan(X)
|
||||
#define my_isinf(X) std::isinf(X)
|
||||
#else
|
||||
#ifdef HAVE_LLVM_LIBCPP /* finite is deprecated in libc++ */
|
||||
#define my_isfinite(X) isfinite(X)
|
||||
#elif defined _WIN32
|
||||
#define my_isfinite(X) _finite(X)
|
||||
#else
|
||||
#define my_isfinite(X) finite(X)
|
||||
#endif
|
||||
#define my_isnan(X) isnan(X)
|
||||
#ifdef HAVE_ISINF
|
||||
/* System-provided isinf() is available and safe to use */
|
||||
#define my_isinf(X) isinf(X)
|
||||
#else /* !HAVE_ISINF */
|
||||
#define my_isinf(X) (!my_isfinite(X) && !my_isnan(X))
|
||||
#endif
|
||||
#endif /* __cplusplus >= 201103L */
|
||||
|
||||
/*
|
||||
Max size that must be added to a so that we know Size to make
|
||||
adressable obj.
|
||||
*/
|
||||
#if SIZEOF_CHARP == 4
|
||||
typedef long my_ptrdiff_t;
|
||||
#else
|
||||
typedef long long my_ptrdiff_t;
|
||||
#endif
|
||||
|
||||
#define MY_ALIGN(A,L) (((A) + (L) - 1) & ~((L) - 1))
|
||||
#define ALIGN_SIZE(A) MY_ALIGN((A),sizeof(double))
|
||||
/* Size to make adressable obj. */
|
||||
#define ADD_TO_PTR(ptr,size,type) (type) ((uchar*) (ptr)+size)
|
||||
#define PTR_BYTE_DIFF(A,B) (my_ptrdiff_t) ((uchar*) (A) - (uchar*) (B))
|
||||
|
||||
/*
|
||||
Custom version of standard offsetof() macro which can be used to get
|
||||
offsets of members in class for non-POD types (according to the current
|
||||
version of C++ standard offsetof() macro can't be used in such cases and
|
||||
attempt to do so causes warnings to be emitted, OTOH in many cases it is
|
||||
still OK to assume that all instances of the class has the same offsets
|
||||
for the same members).
|
||||
|
||||
This is temporary solution which should be removed once File_parser class
|
||||
and related routines are refactored.
|
||||
*/
|
||||
|
||||
#define my_offsetof(TYPE, MEMBER) \
|
||||
((size_t)((char *)&(((TYPE *)0x10)->MEMBER) - (char*)0x10))
|
||||
|
||||
#define NullS (char *) 0
|
||||
|
||||
#ifdef _WIN32
|
||||
#define STDCALL __stdcall
|
||||
#else
|
||||
#define STDCALL
|
||||
#endif
|
||||
|
||||
/* Typdefs for easyier portability */
|
||||
|
||||
typedef unsigned char uchar; /* Short for unsigned char */
|
||||
typedef signed char int8; /* Signed integer >= 8 bits */
|
||||
typedef unsigned char uint8; /* Unsigned integer >= 8 bits */
|
||||
typedef short int16;
|
||||
typedef unsigned short uint16;
|
||||
#if SIZEOF_INT == 4
|
||||
typedef int int32;
|
||||
typedef unsigned int uint32;
|
||||
#elif SIZEOF_LONG == 4
|
||||
typedef long int32;
|
||||
typedef unsigned long uint32;
|
||||
#else
|
||||
#error Neither int or long is of 4 bytes width
|
||||
#endif
|
||||
|
||||
#if !defined(HAVE_ULONG)
|
||||
typedef unsigned long ulong; /* Short for unsigned long */
|
||||
#endif
|
||||
/*
|
||||
Using [unsigned] long long is preferable as [u]longlong because we use
|
||||
[unsigned] long long unconditionally in many places,
|
||||
for example in constants with [U]LL suffix.
|
||||
*/
|
||||
typedef unsigned long long int ulonglong; /* ulong or unsigned long long */
|
||||
typedef long long int longlong;
|
||||
typedef longlong int64;
|
||||
typedef ulonglong uint64;
|
||||
|
||||
#if defined (_WIN32)
|
||||
typedef unsigned __int64 my_ulonglong;
|
||||
#else
|
||||
typedef unsigned long long my_ulonglong;
|
||||
#endif
|
||||
|
||||
#if SIZEOF_CHARP == SIZEOF_INT
|
||||
typedef int intptr;
|
||||
#elif SIZEOF_CHARP == SIZEOF_LONG
|
||||
typedef long intptr;
|
||||
#elif SIZEOF_CHARP == SIZEOF_LONG_LONG
|
||||
typedef long long intptr;
|
||||
#else
|
||||
#error sizeof(void *) is neither sizeof(int) nor sizeof(long) nor sizeof(long long)
|
||||
#endif
|
||||
|
||||
#define MY_ERRPTR ((void*)(intptr)1)
|
||||
|
||||
#if defined(_WIN32)
|
||||
typedef unsigned long long my_off_t;
|
||||
typedef unsigned long long os_off_t;
|
||||
#else
|
||||
typedef off_t os_off_t;
|
||||
#if SIZEOF_OFF_T > 4
|
||||
typedef ulonglong my_off_t;
|
||||
#else
|
||||
typedef unsigned long my_off_t;
|
||||
#endif
|
||||
#endif /*_WIN32*/
|
||||
#define MY_FILEPOS_ERROR (~(my_off_t) 0)
|
||||
|
||||
/*
|
||||
TODO Convert these to use Bitmap class.
|
||||
*/
|
||||
typedef ulonglong table_map; /* Used for table bits in join */
|
||||
typedef ulonglong nesting_map; /* Used for flags of nesting constructs */
|
||||
|
||||
#if defined(_WIN32)
|
||||
#define socket_errno WSAGetLastError()
|
||||
#define SOCKET_EINTR WSAEINTR
|
||||
#define SOCKET_EAGAIN WSAEINPROGRESS
|
||||
#define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK
|
||||
#define SOCKET_EADDRINUSE WSAEADDRINUSE
|
||||
#define SOCKET_ETIMEDOUT WSAETIMEDOUT
|
||||
#define SOCKET_ECONNRESET WSAECONNRESET
|
||||
#define SOCKET_ENFILE ENFILE
|
||||
#define SOCKET_EMFILE EMFILE
|
||||
#else /* Unix */
|
||||
#define socket_errno errno
|
||||
#define closesocket(A) close(A)
|
||||
#define SOCKET_EINTR EINTR
|
||||
#define SOCKET_EAGAIN EAGAIN
|
||||
#define SOCKET_EWOULDBLOCK EWOULDBLOCK
|
||||
#define SOCKET_EADDRINUSE EADDRINUSE
|
||||
#define SOCKET_ETIMEDOUT ETIMEDOUT
|
||||
#define SOCKET_ECONNRESET ECONNRESET
|
||||
#define SOCKET_ENFILE ENFILE
|
||||
#define SOCKET_EMFILE EMFILE
|
||||
#endif
|
||||
|
||||
typedef int myf; /* Type of MyFlags in my_funcs */
|
||||
typedef char my_bool; /* Small bool */
|
||||
|
||||
/* Macros for converting *constants* to the right type */
|
||||
#define MYF(v) (myf) (v)
|
||||
|
||||
/* Some helper macros */
|
||||
#define YESNO(X) ((X) ? "yes" : "no")
|
||||
|
||||
#define MY_HOW_OFTEN_TO_WRITE 1000 /* How often we want info on screen */
|
||||
|
||||
#include <my_byteorder.h>
|
||||
|
||||
#ifdef HAVE_CHARSET_utf8
|
||||
#define MYSQL_UNIVERSAL_CLIENT_CHARSET "utf8"
|
||||
#else
|
||||
#define MYSQL_UNIVERSAL_CLIENT_CHARSET MYSQL_DEFAULT_CHARSET_NAME
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32)
|
||||
#define dlsym(lib, name) (void*)GetProcAddress((HMODULE)lib, name)
|
||||
#define dlopen(libname, unused) LoadLibraryEx(libname, NULL, 0)
|
||||
#define dlclose(lib) FreeLibrary((HMODULE)lib)
|
||||
#ifndef HAVE_DLOPEN
|
||||
#define HAVE_DLOPEN
|
||||
#endif
|
||||
#define DLERROR_GENERATE(errmsg, error_number) \
|
||||
char win_errormsg[2048]; \
|
||||
if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, \
|
||||
0, error_number, 0, win_errormsg, 2048, NULL)) \
|
||||
{ \
|
||||
char *ptr; \
|
||||
for (ptr= &win_errormsg[0] + strlen(win_errormsg) - 1; \
|
||||
ptr >= &win_errormsg[0] && strchr("\r\n\t\0x20", *ptr); \
|
||||
ptr--) \
|
||||
*ptr= 0; \
|
||||
errmsg= win_errormsg; \
|
||||
} \
|
||||
else \
|
||||
errmsg= ""
|
||||
#define dlerror() ""
|
||||
#define dlopen_errno GetLastError()
|
||||
|
||||
#else /* _WIN32 */
|
||||
#define DLERROR_GENERATE(errmsg, error_number) errmsg= dlerror()
|
||||
#define dlopen_errno errno
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/* Length of decimal number represented by INT32. */
|
||||
#define MY_INT32_NUM_DECIMAL_DIGITS 11U
|
||||
|
||||
/* Length of decimal number represented by INT64. */
|
||||
#define MY_INT64_NUM_DECIMAL_DIGITS 21U
|
||||
|
||||
/* Define some useful general macros (should be done after all headers). */
|
||||
#define MY_MAX(a, b) ((a) > (b) ? (a) : (b))
|
||||
#define MY_MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
|
||||
#if !defined(__cplusplus) && !defined(bool)
|
||||
#define bool In_C_you_should_use_my_bool_instead()
|
||||
#endif
|
||||
|
||||
/*
|
||||
MYSQL_PLUGIN_IMPORT macro is used to export mysqld data
|
||||
(i.e variables) for usage in storage engine loadable plugins.
|
||||
Outside of Windows, it is dummy.
|
||||
*/
|
||||
#if (defined(_WIN32) && defined(MYSQL_DYNAMIC_PLUGIN))
|
||||
#define MYSQL_PLUGIN_IMPORT __declspec(dllimport)
|
||||
#else
|
||||
#define MYSQL_PLUGIN_IMPORT
|
||||
#endif
|
||||
|
||||
#include <my_dbug.h>
|
||||
|
||||
#ifdef EMBEDDED_LIBRARY
|
||||
#define NO_EMBEDDED_ACCESS_CHECKS
|
||||
/* Things we don't need in the embedded version of MySQL */
|
||||
#undef HAVE_OPENSSL
|
||||
#endif /* EMBEDDED_LIBRARY */
|
||||
|
||||
|
||||
enum loglevel {
|
||||
ERROR_LEVEL= 0,
|
||||
WARNING_LEVEL= 1,
|
||||
INFORMATION_LEVEL= 2
|
||||
};
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
/****************************************************************************
|
||||
** Replacements for localtime_r and gmtime_r
|
||||
****************************************************************************/
|
||||
|
||||
static inline struct tm *localtime_r(const time_t *timep, struct tm *tmp)
|
||||
{
|
||||
localtime_s(tmp, timep);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static inline struct tm *gmtime_r(const time_t *clock, struct tm *res)
|
||||
{
|
||||
gmtime_s(res, clock);
|
||||
return res;
|
||||
}
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifndef HAVE_STRUCT_TIMESPEC /* Windows before VS2015 */
|
||||
/*
|
||||
Declare a union to make sure FILETIME is properly aligned
|
||||
so it can be used directly as a 64 bit value. The value
|
||||
stored is in 100ns units.
|
||||
*/
|
||||
union ft64 {
|
||||
FILETIME ft;
|
||||
__int64 i64;
|
||||
};
|
||||
|
||||
struct timespec {
|
||||
union ft64 tv;
|
||||
/* The max timeout value in millisecond for native_cond_timedwait */
|
||||
long max_timeout_msec;
|
||||
};
|
||||
|
||||
#endif /* !HAVE_STRUCT_TIMESPEC */
|
||||
|
||||
C_MODE_START
|
||||
extern ulonglong my_getsystime(void);
|
||||
C_MODE_END
|
||||
|
||||
static inline void set_timespec_nsec(struct timespec *abstime, ulonglong nsec)
|
||||
{
|
||||
#ifdef HAVE_STRUCT_TIMESPEC
|
||||
ulonglong now= my_getsystime() + (nsec / 100);
|
||||
ulonglong tv_sec= now / 10000000ULL;
|
||||
#if SIZEOF_TIME_T < SIZEOF_LONG_LONG
|
||||
/* Ensure that the number of seconds don't overflow. */
|
||||
tv_sec= MY_MIN(tv_sec, ((ulonglong)INT_MAX32));
|
||||
#endif
|
||||
abstime->tv_sec= (time_t)tv_sec;
|
||||
abstime->tv_nsec= (now % 10000000ULL) * 100 + (nsec % 100);
|
||||
#else /* !HAVE_STRUCT_TIMESPEC */
|
||||
ulonglong max_timeout_msec= (nsec / 1000000);
|
||||
union ft64 tv;
|
||||
GetSystemTimeAsFileTime(&tv.ft);
|
||||
abstime->tv.i64= tv.i64 + (__int64)(nsec / 100);
|
||||
#if SIZEOF_LONG < SIZEOF_LONG_LONG
|
||||
/* Ensure that the msec value doesn't overflow. */
|
||||
max_timeout_msec= MY_MIN(max_timeout_msec, ((ulonglong)INT_MAX32));
|
||||
#endif
|
||||
abstime->max_timeout_msec= (long)max_timeout_msec;
|
||||
#endif /* !HAVE_STRUCT_TIMESPEC */
|
||||
}
|
||||
|
||||
static inline void set_timespec(struct timespec *abstime, ulonglong sec)
|
||||
{
|
||||
set_timespec_nsec(abstime, sec * 1000000000ULL);
|
||||
}
|
||||
|
||||
/**
|
||||
Compare two timespec structs.
|
||||
|
||||
@retval 1 If ts1 ends after ts2.
|
||||
@retval -1 If ts1 ends before ts2.
|
||||
@retval 0 If ts1 is equal to ts2.
|
||||
*/
|
||||
static inline int cmp_timespec(struct timespec *ts1, struct timespec *ts2)
|
||||
{
|
||||
#ifdef HAVE_STRUCT_TIMESPEC
|
||||
if (ts1->tv_sec > ts2->tv_sec ||
|
||||
(ts1->tv_sec == ts2->tv_sec && ts1->tv_nsec > ts2->tv_nsec))
|
||||
return 1;
|
||||
if (ts1->tv_sec < ts2->tv_sec ||
|
||||
(ts1->tv_sec == ts2->tv_sec && ts1->tv_nsec < ts2->tv_nsec))
|
||||
return -1;
|
||||
#else
|
||||
if (ts1->tv.i64 > ts2->tv.i64)
|
||||
return 1;
|
||||
if (ts1->tv.i64 < ts2->tv.i64)
|
||||
return -1;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline ulonglong diff_timespec(struct timespec *ts1, struct timespec *ts2)
|
||||
{
|
||||
#ifdef HAVE_STRUCT_TIMESPEC
|
||||
return (ts1->tv_sec - ts2->tv_sec) * 1000000000ULL +
|
||||
ts1->tv_nsec - ts2->tv_nsec;
|
||||
#else
|
||||
return (ts1->tv.i64 - ts2->tv.i64) * 100;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
typedef int MY_MODE;
|
||||
#else
|
||||
typedef mode_t MY_MODE;
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/* File permissions */
|
||||
#define USER_READ (1L << 0)
|
||||
#define USER_WRITE (1L << 1)
|
||||
#define USER_EXECUTE (1L << 2)
|
||||
#define GROUP_READ (1L << 3)
|
||||
#define GROUP_WRITE (1L << 4)
|
||||
#define GROUP_EXECUTE (1L << 5)
|
||||
#define OTHERS_READ (1L << 6)
|
||||
#define OTHERS_WRITE (1L << 7)
|
||||
#define OTHERS_EXECUTE (1L << 8)
|
||||
#define USER_RWX USER_READ | USER_WRITE | USER_EXECUTE
|
||||
#define GROUP_RWX GROUP_READ | GROUP_WRITE | GROUP_EXECUTE
|
||||
#define OTHERS_RWX OTHERS_READ | OTHERS_WRITE | OTHERS_EXECUTE
|
||||
|
||||
/* Defaults */
|
||||
#define DEFAULT_SSL_CA_CERT "ca.pem"
|
||||
#define DEFAULT_SSL_CA_KEY "ca-key.pem"
|
||||
#define DEFAULT_SSL_SERVER_CERT "server-cert.pem"
|
||||
#define DEFAULT_SSL_SERVER_KEY "server-key.pem"
|
||||
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
#define strcasecmp _stricmp
|
||||
#endif
|
||||
#endif // MY_GLOBAL_INCLUDED
|
|
@ -25,28 +25,33 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MY_LIST_INCLUDED
|
||||
#define MY_LIST_INCLUDED
|
||||
#ifndef _list_h_
|
||||
#define _list_h_
|
||||
|
||||
/**
|
||||
@file include/my_list.h
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct LIST {
|
||||
struct LIST *prev, *next;
|
||||
typedef struct st_list {
|
||||
struct st_list *prev,*next;
|
||||
void *data;
|
||||
} LIST;
|
||||
|
||||
typedef int (*list_walk_action)(void *, void *);
|
||||
typedef int (*list_walk_action)(void *,void *);
|
||||
|
||||
extern LIST *list_add(LIST *root, LIST *element);
|
||||
extern LIST *list_delete(LIST *root, LIST *element);
|
||||
extern LIST *list_cons(void *data, LIST *root);
|
||||
extern LIST *list_add(LIST *root,LIST *element);
|
||||
extern LIST *list_delete(LIST *root,LIST *element);
|
||||
extern LIST *list_cons(void *data,LIST *root);
|
||||
extern LIST *list_reverse(LIST *root);
|
||||
extern void list_free(LIST *root, unsigned int free_data);
|
||||
extern void list_free(LIST *root,unsigned int free_data);
|
||||
extern unsigned int list_length(LIST *);
|
||||
extern int list_walk(LIST *, list_walk_action action, unsigned char *argument);
|
||||
extern int list_walk(LIST *,list_walk_action action,unsigned char * argument);
|
||||
|
||||
#define list_rest(a) ((a)->next)
|
||||
#define list_push(a,b) (a)=list_cons((b),(a))
|
||||
#define list_pop(A) {LIST *old=(A); (A)=list_delete(old,old); my_free(old); }
|
||||
|
||||
#endif // MY_LIST_INCLUDED
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -0,0 +1,992 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef _my_sys_h
|
||||
#define _my_sys_h
|
||||
|
||||
#include "my_global.h" /* C_MODE_START, C_MODE_END */
|
||||
#include "m_ctype.h" /* for CHARSET_INFO */
|
||||
|
||||
#include "my_thread.h" /* Needed for psi.h */
|
||||
#include "mysql/psi/psi.h"
|
||||
#include "mysql/service_mysql_alloc.h"
|
||||
#include "mysql/psi/mysql_memory.h"
|
||||
#include "mysql/psi/mysql_thread.h"
|
||||
|
||||
#ifdef HAVE_ALLOCA_H
|
||||
#include <alloca.h>
|
||||
#endif
|
||||
#ifdef _WIN32
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
#ifdef HAVE_UNISTD_H
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <sys/stat.h>
|
||||
|
||||
C_MODE_START
|
||||
|
||||
#ifdef HAVE_VALGRIND
|
||||
# include <valgrind/valgrind.h>
|
||||
# define MEM_MALLOCLIKE_BLOCK(p1, p2, p3, p4) VALGRIND_MALLOCLIKE_BLOCK(p1, p2, p3, p4)
|
||||
# define MEM_FREELIKE_BLOCK(p1, p2) VALGRIND_FREELIKE_BLOCK(p1, p2)
|
||||
# include <valgrind/memcheck.h>
|
||||
# define MEM_UNDEFINED(a,len) VALGRIND_MAKE_MEM_UNDEFINED(a,len)
|
||||
# define MEM_NOACCESS(a,len) VALGRIND_MAKE_MEM_NOACCESS(a,len)
|
||||
# define MEM_CHECK_ADDRESSABLE(a,len) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(a,len)
|
||||
#else /* HAVE_VALGRIND */
|
||||
# define MEM_MALLOCLIKE_BLOCK(p1, p2, p3, p4) do {} while (0)
|
||||
# define MEM_FREELIKE_BLOCK(p1, p2) do {} while (0)
|
||||
# define MEM_UNDEFINED(a,len) ((void) 0)
|
||||
# define MEM_NOACCESS(a,len) ((void) 0)
|
||||
# define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
|
||||
#endif /* HAVE_VALGRIND */
|
||||
|
||||
#include <typelib.h>
|
||||
|
||||
#define MY_INIT(name) { my_progname= name; my_init(); }
|
||||
|
||||
/**
|
||||
Max length of an error message generated by mysys utilities.
|
||||
Some mysys functions produce error messages. These mostly go
|
||||
to stderr.
|
||||
This constant defines the size of the buffer used to format
|
||||
the message. It should be kept in sync with MYSQL_ERRMSG_SIZE,
|
||||
since sometimes mysys errors are stored in the server diagnostics
|
||||
area, and we would like to avoid unexpected truncation.
|
||||
*/
|
||||
#define MYSYS_ERRMSG_SIZE (512)
|
||||
#define MYSYS_STRERROR_SIZE (128)
|
||||
|
||||
#define MY_FILE_ERROR ((size_t) -1)
|
||||
|
||||
/* General bitmaps for my_func's */
|
||||
#define MY_FFNF 1 /* Fatal if file not found */
|
||||
#define MY_FNABP 2 /* Fatal if not all bytes read/writen */
|
||||
#define MY_NABP 4 /* Error if not all bytes read/writen */
|
||||
#define MY_FAE 8 /* Fatal if any error */
|
||||
#define MY_WME 16 /* Write message on error */
|
||||
#define MY_WAIT_IF_FULL 32 /* Wait and try again if disk full error */
|
||||
#define MY_IGNORE_BADFD 32 /* my_sync: ignore 'bad descriptor' errors */
|
||||
#define MY_SYNC_DIR 8192 /* my_create/delete/rename: sync directory */
|
||||
#define MY_UNUSED 64 /* Unused (was support for RAID) */
|
||||
#define MY_FULL_IO 512 /* For my_read - loop intil I/O is complete */
|
||||
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
|
||||
#define MY_LINK_WARNING 32 /* my_redel() gives warning if links */
|
||||
#define MY_COPYTIME 64 /* my_redel() copys time */
|
||||
#define MY_DELETE_OLD 256 /* my_create_with_symlink() */
|
||||
#define MY_RESOLVE_LINK 128 /* my_realpath(); Only resolve links */
|
||||
#define MY_HOLD_ORIGINAL_MODES 128 /* my_copy() holds to file modes */
|
||||
#define MY_REDEL_MAKE_BACKUP 256
|
||||
#define MY_REDEL_NO_COPY_STAT 512 /* my_redel() doesn't call my_copystat() */
|
||||
#define MY_SEEK_NOT_DONE 32 /* my_lock may have to do a seek */
|
||||
#define MY_DONT_WAIT 64 /* my_lock() don't wait if can't lock */
|
||||
#define MY_ZEROFILL 32 /* my_malloc(), fill array with zero */
|
||||
#define MY_ALLOW_ZERO_PTR 64 /* my_realloc() ; zero ptr -> malloc */
|
||||
#define MY_FREE_ON_ERROR 128 /* my_realloc() ; Free old ptr on error */
|
||||
#define MY_HOLD_ON_ERROR 256 /* my_realloc() ; Return old ptr on error */
|
||||
#define MY_DONT_OVERWRITE_FILE 1024 /* my_copy: Don't overwrite file */
|
||||
#define MY_THREADSAFE 2048 /* my_seek(): lock fd mutex */
|
||||
#define MY_SYNC 4096 /* my_copy(): sync dst file */
|
||||
|
||||
#define MYF_RW MYF(MY_WME+MY_NABP) /* For my_read & my_write */
|
||||
|
||||
#define MY_CHECK_ERROR 1 /* Params to my_end; Check open-close */
|
||||
#define MY_GIVE_INFO 2 /* Give time info about process*/
|
||||
#define MY_DONT_FREE_DBUG 4 /* Do not call DBUG_END() in my_end() */
|
||||
|
||||
/* Flags for my_error() */
|
||||
#define ME_BELL 4 /* DEPRECATED: Ring bell then printing message */
|
||||
#define ME_ERRORLOG 64 /* Write the error message to error log */
|
||||
#define ME_FATALERROR 1024 /* Fatal statement error */
|
||||
|
||||
/* Bits in last argument to fn_format */
|
||||
#define MY_REPLACE_DIR 1 /* replace dir in name with 'dir' */
|
||||
#define MY_REPLACE_EXT 2 /* replace extension with 'ext' */
|
||||
#define MY_UNPACK_FILENAME 4 /* Unpack name (~ -> home) */
|
||||
#define MY_PACK_FILENAME 8 /* Pack name (home -> ~) */
|
||||
#define MY_RESOLVE_SYMLINKS 16 /* Resolve all symbolic links */
|
||||
#define MY_RETURN_REAL_PATH 32 /* return full path for file */
|
||||
#define MY_SAFE_PATH 64 /* Return NULL if too long path */
|
||||
#define MY_RELATIVE_PATH 128 /* name is relative to 'dir' */
|
||||
#define MY_APPEND_EXT 256 /* add 'ext' as additional extension*/
|
||||
|
||||
|
||||
/* My seek flags */
|
||||
#define MY_SEEK_SET 0
|
||||
#define MY_SEEK_CUR 1
|
||||
#define MY_SEEK_END 2
|
||||
|
||||
/* Some constants */
|
||||
#define MY_WAIT_FOR_USER_TO_FIX_PANIC 60 /* in seconds */
|
||||
#define MY_WAIT_GIVE_USER_A_MESSAGE 10 /* Every 10 times of prev */
|
||||
#define MIN_COMPRESS_LENGTH 50 /* Don't compress small bl. */
|
||||
#define DFLT_INIT_HITS 3
|
||||
|
||||
/* root_alloc flags */
|
||||
#define MY_KEEP_PREALLOC 1
|
||||
#define MY_MARK_BLOCKS_FREE 2 /* move used to free list and reuse them */
|
||||
|
||||
/* Internal error numbers (for assembler functions) */
|
||||
#define MY_ERRNO_EDOM 33
|
||||
#define MY_ERRNO_ERANGE 34
|
||||
|
||||
/* Bits for get_date timeflag */
|
||||
#define GETDATE_DATE_TIME 1
|
||||
#define GETDATE_SHORT_DATE 2
|
||||
#define GETDATE_HHMMSSTIME 4
|
||||
#define GETDATE_GMT 8
|
||||
#define GETDATE_FIXEDLENGTH 16
|
||||
#define GETDATE_T_DELIMITER 32
|
||||
#define GETDATE_SHORT_DATE_FULL_YEAR 64
|
||||
|
||||
/* defines when allocating data */
|
||||
extern void *my_multi_malloc(PSI_memory_key key, myf flags, ...);
|
||||
|
||||
/*
|
||||
Switch to my_malloc() if the memory block to be allocated is bigger than
|
||||
max_alloca_sz.
|
||||
*/
|
||||
extern PSI_memory_key key_memory_max_alloca;
|
||||
#define my_safe_alloca(size, max_alloca_sz) ((size <= max_alloca_sz) ? \
|
||||
my_alloca(size) : \
|
||||
my_malloc(key_memory_max_alloca, size, MYF(0)))
|
||||
#define my_safe_afree(ptr, size, max_alloca_sz) if (size > max_alloca_sz) \
|
||||
my_free(ptr)
|
||||
|
||||
#if !defined(NDEBUG) || defined(HAVE_VALGRIND)
|
||||
/**
|
||||
Put bad content in memory to be sure it will segfault if dereferenced.
|
||||
With Valgrind, verify that memory is addressable, and mark it undefined.
|
||||
We cache value of B because if B is expression which depends on A, memset()
|
||||
trashes value of B.
|
||||
*/
|
||||
#define TRASH(A,B) do { \
|
||||
void *p = (A); \
|
||||
const size_t l= (B); \
|
||||
MEM_CHECK_ADDRESSABLE(A, l); \
|
||||
memset(p, 0x8F, l); \
|
||||
MEM_UNDEFINED(A, l); \
|
||||
} while (0)
|
||||
#else
|
||||
#define TRASH(A,B) do {} while(0)
|
||||
#endif
|
||||
#if defined(ENABLED_DEBUG_SYNC)
|
||||
extern void (*debug_sync_C_callback_ptr)(const char *, size_t);
|
||||
#define DEBUG_SYNC_C(_sync_point_name_) do { \
|
||||
if (debug_sync_C_callback_ptr != NULL) \
|
||||
(*debug_sync_C_callback_ptr)(STRING_WITH_LEN(_sync_point_name_)); } \
|
||||
while(0)
|
||||
#define DEBUG_SYNC_C_IF_THD(thd, _sync_point_name_) do { \
|
||||
if (debug_sync_C_callback_ptr != NULL && thd) \
|
||||
(*debug_sync_C_callback_ptr)(STRING_WITH_LEN(_sync_point_name_)); } \
|
||||
while(0)
|
||||
#else
|
||||
#define DEBUG_SYNC_C(_sync_point_name_)
|
||||
#define DEBUG_SYNC_C_IF_THD(thd, _sync_point_name_)
|
||||
#endif /* defined(ENABLED_DEBUG_SYNC) */
|
||||
|
||||
#ifdef HAVE_LINUX_LARGE_PAGES
|
||||
extern uint my_get_large_page_size(void);
|
||||
extern uchar * my_large_malloc(PSI_memory_key key, size_t size, myf my_flags);
|
||||
extern void my_large_free(uchar *ptr);
|
||||
extern my_bool my_use_large_pages;
|
||||
extern uint my_large_page_size;
|
||||
#else
|
||||
#define my_get_large_page_size() (0)
|
||||
#define my_large_malloc(A,B,C) my_malloc((A),(B),(C))
|
||||
#define my_large_free(A) my_free((A))
|
||||
#endif /* HAVE_LINUX_LARGE_PAGES */
|
||||
|
||||
#define my_alloca(SZ) alloca((size_t) (SZ))
|
||||
|
||||
#include <errno.h> /* errno is a define */
|
||||
|
||||
extern char *home_dir; /* Home directory for user */
|
||||
extern const char *my_progname; /* program-name (printed in errors) */
|
||||
extern char curr_dir[]; /* Current directory for user */
|
||||
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
|
||||
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
|
||||
myf MyFlags);
|
||||
extern void (*local_message_hook)(enum loglevel ll,
|
||||
const char *format, va_list args);
|
||||
extern uint my_file_limit;
|
||||
extern MYSQL_PLUGIN_IMPORT ulong my_thread_stack_size;
|
||||
|
||||
/*
|
||||
Hooks for reporting execution stage information. The server implementation
|
||||
of these will also set THD::current_cond/current_mutex.
|
||||
By having hooks, we avoid direct dependencies on server code.
|
||||
*/
|
||||
extern void (*enter_cond_hook)(void *opaque_thd,
|
||||
mysql_cond_t *cond,
|
||||
mysql_mutex_t *mutex,
|
||||
const PSI_stage_info *stage,
|
||||
PSI_stage_info *old_stage,
|
||||
const char *src_function,
|
||||
const char *src_file,
|
||||
int src_line);
|
||||
|
||||
extern void (*exit_cond_hook)(void *opaque_thd,
|
||||
const PSI_stage_info *stage,
|
||||
const char *src_function,
|
||||
const char *src_file,
|
||||
int src_line);
|
||||
|
||||
/*
|
||||
Hook for checking if the thread has been killed.
|
||||
*/
|
||||
extern int (*is_killed_hook)(const void *opaque_thd);
|
||||
|
||||
/* charsets */
|
||||
#define MY_ALL_CHARSETS_SIZE 2048
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *default_charset_info;
|
||||
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *all_charsets[MY_ALL_CHARSETS_SIZE];
|
||||
extern CHARSET_INFO compiled_charsets[];
|
||||
|
||||
/* statistics */
|
||||
extern ulong my_file_opened,my_stream_opened, my_tmp_file_created;
|
||||
extern ulong my_file_total_opened;
|
||||
extern my_bool my_init_done;
|
||||
|
||||
extern MYSQL_PLUGIN_IMPORT int my_umask; /* Default creation mask */
|
||||
extern int my_umask_dir;
|
||||
|
||||
extern ulong my_default_record_cache_size;
|
||||
extern my_bool my_disable_locking,
|
||||
my_enable_symlinks;
|
||||
extern char wild_many,wild_one,wild_prefix;
|
||||
extern const char *charsets_dir;
|
||||
|
||||
enum cache_type
|
||||
{
|
||||
TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
|
||||
SEQ_READ_APPEND /* sequential read or append */,
|
||||
READ_FIFO, READ_NET,WRITE_NET};
|
||||
|
||||
enum flush_type
|
||||
{
|
||||
FLUSH_KEEP, /* flush block and keep it in the cache */
|
||||
FLUSH_RELEASE, /* flush block and remove it from the cache */
|
||||
FLUSH_IGNORE_CHANGED, /* remove block from the cache */
|
||||
/*
|
||||
As my_disable_flush_pagecache_blocks is always 0, the following option
|
||||
is strictly equivalent to FLUSH_KEEP
|
||||
*/
|
||||
FLUSH_FORCE_WRITE
|
||||
};
|
||||
|
||||
enum file_type
|
||||
{
|
||||
UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
|
||||
FILE_BY_MKSTEMP, FILE_BY_DUP
|
||||
};
|
||||
|
||||
struct st_my_file_info
|
||||
{
|
||||
char *name;
|
||||
#ifdef _WIN32
|
||||
HANDLE fhandle; /* win32 file handle */
|
||||
int oflag; /* open flags, e.g O_APPEND */
|
||||
#endif
|
||||
enum file_type type;
|
||||
};
|
||||
|
||||
extern struct st_my_file_info *my_file_info;
|
||||
|
||||
/* needed for client-only build */
|
||||
#ifndef PSI_FILE_KEY_DEFINED
|
||||
typedef unsigned int PSI_file_key;
|
||||
#define PSI_FILE_KEY_DEFINED
|
||||
#endif
|
||||
|
||||
typedef struct st_dynamic_array
|
||||
{
|
||||
uchar *buffer;
|
||||
uint elements,max_element;
|
||||
uint alloc_increment;
|
||||
uint size_of_element;
|
||||
PSI_memory_key m_psi_key;
|
||||
} DYNAMIC_ARRAY;
|
||||
|
||||
typedef struct st_my_tmpdir
|
||||
{
|
||||
char **list;
|
||||
uint cur, max;
|
||||
mysql_mutex_t mutex;
|
||||
} MY_TMPDIR;
|
||||
|
||||
typedef struct st_dynamic_string
|
||||
{
|
||||
char *str;
|
||||
size_t length,max_length,alloc_increment;
|
||||
} DYNAMIC_STRING;
|
||||
|
||||
struct st_io_cache;
|
||||
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
|
||||
|
||||
typedef struct st_io_cache_share
|
||||
{
|
||||
mysql_mutex_t mutex; /* To sync on reads into buffer. */
|
||||
mysql_cond_t cond; /* To wait for signals. */
|
||||
mysql_cond_t cond_writer; /* For a synchronized writer. */
|
||||
/* Offset in file corresponding to the first byte of buffer. */
|
||||
my_off_t pos_in_file;
|
||||
/* If a synchronized write cache is the source of the data. */
|
||||
struct st_io_cache *source_cache;
|
||||
uchar *buffer; /* The read buffer. */
|
||||
uchar *read_end; /* Behind last valid byte of buffer. */
|
||||
int running_threads; /* threads not in lock. */
|
||||
int total_threads; /* threads sharing the cache. */
|
||||
int error; /* Last error. */
|
||||
} IO_CACHE_SHARE;
|
||||
|
||||
typedef struct st_io_cache /* Used when cacheing files */
|
||||
{
|
||||
/* Offset in file corresponding to the first byte of uchar* buffer. */
|
||||
my_off_t pos_in_file;
|
||||
/*
|
||||
The offset of end of file for READ_CACHE and WRITE_CACHE.
|
||||
For SEQ_READ_APPEND it the maximum of the actual end of file and
|
||||
the position represented by read_end.
|
||||
*/
|
||||
my_off_t end_of_file;
|
||||
/* Points to current read position in the buffer */
|
||||
uchar *read_pos;
|
||||
/* the non-inclusive boundary in the buffer for the currently valid read */
|
||||
uchar *read_end;
|
||||
uchar *buffer; /* The read buffer */
|
||||
/* Used in ASYNC_IO */
|
||||
uchar *request_pos;
|
||||
|
||||
/* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
|
||||
uchar *write_buffer;
|
||||
/*
|
||||
Only used in SEQ_READ_APPEND, and points to the current read position
|
||||
in the write buffer. Note that reads in SEQ_READ_APPEND caches can
|
||||
happen from both read buffer (uchar* buffer) and write buffer
|
||||
(uchar* write_buffer).
|
||||
*/
|
||||
uchar *append_read_pos;
|
||||
/* Points to current write position in the write buffer */
|
||||
uchar *write_pos;
|
||||
/* The non-inclusive boundary of the valid write area */
|
||||
uchar *write_end;
|
||||
|
||||
/*
|
||||
Current_pos and current_end are convenience variables used by
|
||||
my_b_tell() and other routines that need to know the current offset
|
||||
current_pos points to &write_pos, and current_end to &write_end in a
|
||||
WRITE_CACHE, and &read_pos and &read_end respectively otherwise
|
||||
*/
|
||||
uchar **current_pos, **current_end;
|
||||
|
||||
/*
|
||||
The lock is for append buffer used in SEQ_READ_APPEND cache
|
||||
need mutex copying from append buffer to read buffer.
|
||||
*/
|
||||
mysql_mutex_t append_buffer_lock;
|
||||
/*
|
||||
The following is used when several threads are reading the
|
||||
same file in parallel. They are synchronized on disk
|
||||
accesses reading the cached part of the file asynchronously.
|
||||
It should be set to NULL to disable the feature. Only
|
||||
READ_CACHE mode is supported.
|
||||
*/
|
||||
IO_CACHE_SHARE *share;
|
||||
|
||||
/*
|
||||
A caller will use my_b_read() macro to read from the cache
|
||||
if the data is already in cache, it will be simply copied with
|
||||
memcpy() and internal variables will be accordinging updated with
|
||||
no functions invoked. However, if the data is not fully in the cache,
|
||||
my_b_read() will call read_function to fetch the data. read_function
|
||||
must never be invoked directly.
|
||||
*/
|
||||
int (*read_function)(struct st_io_cache *,uchar *,size_t);
|
||||
/*
|
||||
Same idea as in the case of read_function, except my_b_write() needs to
|
||||
be replaced with my_b_append() for a SEQ_READ_APPEND cache
|
||||
*/
|
||||
int (*write_function)(struct st_io_cache *,const uchar *,size_t);
|
||||
/*
|
||||
Specifies the type of the cache. Depending on the type of the cache
|
||||
certain operations might not be available and yield unpredicatable
|
||||
results. Details to be documented later
|
||||
*/
|
||||
enum cache_type type;
|
||||
/*
|
||||
Callbacks when the actual read I/O happens. These were added and
|
||||
are currently used for binary logging of LOAD DATA INFILE - when a
|
||||
block is read from the file, we create a block create/append event, and
|
||||
when IO_CACHE is closed, we create an end event. These functions could,
|
||||
of course be used for other things
|
||||
*/
|
||||
IO_CACHE_CALLBACK pre_read;
|
||||
IO_CACHE_CALLBACK post_read;
|
||||
IO_CACHE_CALLBACK pre_close;
|
||||
/*
|
||||
Counts the number of times, when we were forced to use disk. We use it to
|
||||
increase the binlog_cache_disk_use and binlog_stmt_cache_disk_use status
|
||||
variables.
|
||||
*/
|
||||
ulong disk_writes;
|
||||
void* arg; /* for use by pre/post_read */
|
||||
char *file_name; /* if used with 'open_cached_file' */
|
||||
char *dir,*prefix;
|
||||
File file; /* file descriptor */
|
||||
PSI_file_key file_key; /* instrumented file key */
|
||||
|
||||
/*
|
||||
seek_not_done is set by my_b_seek() to inform the upcoming read/write
|
||||
operation that a seek needs to be preformed prior to the actual I/O
|
||||
error is 0 if the cache operation was successful, -1 if there was a
|
||||
"hard" error, and the actual number of I/O-ed bytes if the read/write was
|
||||
partial.
|
||||
*/
|
||||
int seek_not_done,error;
|
||||
/* buffer_length is memory size allocated for buffer or write_buffer */
|
||||
size_t buffer_length;
|
||||
/* read_length is the same as buffer_length except when we use async io */
|
||||
size_t read_length;
|
||||
myf myflags; /* Flags used to my_read/my_write */
|
||||
/*
|
||||
alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
|
||||
0 if it was supplied by the user.
|
||||
Currently READ_NET is the only one that will use a buffer allocated
|
||||
somewhere else
|
||||
*/
|
||||
my_bool alloced_buffer;
|
||||
} IO_CACHE;
|
||||
|
||||
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
|
||||
|
||||
/*
|
||||
Subset of struct stat fields filled by stat/lstat/fstat that uniquely
|
||||
identify a file
|
||||
*/
|
||||
typedef struct st_file_id
|
||||
{
|
||||
dev_t st_dev;
|
||||
ino_t st_ino;
|
||||
} ST_FILE_ID;
|
||||
|
||||
typedef void (*my_error_reporter)(enum loglevel level, const char *format, ...)
|
||||
MY_ATTRIBUTE((format(printf, 2, 3)));
|
||||
|
||||
extern my_error_reporter my_charset_error_reporter;
|
||||
|
||||
/* defines for mf_iocache */
|
||||
extern PSI_file_key key_file_io_cache;
|
||||
|
||||
/* Test if buffer is inited */
|
||||
#define my_b_clear(info) (info)->buffer=0
|
||||
#define my_b_inited(info) (info)->buffer
|
||||
#define my_b_EOF INT_MIN
|
||||
|
||||
#define my_b_read(info,Buffer,Count) \
|
||||
((info)->read_pos + (Count) <= (info)->read_end ?\
|
||||
(memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \
|
||||
((info)->read_pos+=(Count)),0) :\
|
||||
(*(info)->read_function)((info),Buffer,Count))
|
||||
|
||||
#define my_b_write(info,Buffer,Count) \
|
||||
((info)->write_pos + (Count) <=(info)->write_end ?\
|
||||
(memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\
|
||||
((info)->write_pos+=(Count)),0) : \
|
||||
(*(info)->write_function)((info),(uchar *)(Buffer),(Count)))
|
||||
|
||||
#define my_b_get(info) \
|
||||
((info)->read_pos != (info)->read_end ?\
|
||||
((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
|
||||
_my_b_get(info))
|
||||
|
||||
#define my_b_tell(info) ((info)->pos_in_file + \
|
||||
(size_t) (*(info)->current_pos - (info)->request_pos))
|
||||
|
||||
#define my_b_get_buffer_start(info) (info)->request_pos
|
||||
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end - \
|
||||
(char*) my_b_get_buffer_start(info)
|
||||
#define my_b_get_pos_in_file(info) (info)->pos_in_file
|
||||
|
||||
/* tell write offset in the SEQ_APPEND cache */
|
||||
int my_b_copy_to_file(IO_CACHE *cache, FILE *file);
|
||||
my_off_t my_b_append_tell(IO_CACHE* info);
|
||||
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
|
||||
|
||||
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
|
||||
*(info)->current_pos)
|
||||
|
||||
typedef uint32 ha_checksum;
|
||||
|
||||
#include <my_alloc.h>
|
||||
|
||||
|
||||
/* Prototypes for mysys and my_func functions */
|
||||
|
||||
extern int my_copy(const char *from,const char *to,myf MyFlags);
|
||||
extern int my_delete(const char *name,myf MyFlags);
|
||||
extern int my_getwd(char * buf,size_t size,myf MyFlags);
|
||||
extern int my_setwd(const char *dir,myf MyFlags);
|
||||
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
|
||||
extern void *my_once_alloc(size_t Size,myf MyFlags);
|
||||
extern void my_once_free(void);
|
||||
extern char *my_once_strdup(const char *src,myf myflags);
|
||||
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
|
||||
extern File my_open(const char *FileName,int Flags,myf MyFlags);
|
||||
extern File my_register_filename(File fd, const char *FileName,
|
||||
enum file_type type_of_file,
|
||||
uint error_message_number, myf MyFlags);
|
||||
extern File my_create(const char *FileName,int CreateFlags,
|
||||
int AccessFlags, myf MyFlags);
|
||||
extern int my_close(File Filedes,myf MyFlags);
|
||||
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
|
||||
extern int my_readlink(char *to, const char *filename, myf MyFlags);
|
||||
extern int my_is_symlink(const char *filename, ST_FILE_ID *file_id);
|
||||
extern int my_realpath(char *to, const char *filename, myf MyFlags);
|
||||
extern int my_is_same_file(File file, const ST_FILE_ID *file_id);
|
||||
extern File my_create_with_symlink(const char *linkname, const char *filename,
|
||||
int createflags, int access_flags,
|
||||
myf MyFlags);
|
||||
extern int my_delete_with_symlink(const char *name, myf MyFlags);
|
||||
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
|
||||
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
|
||||
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
|
||||
extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
|
||||
myf MyFlags);
|
||||
extern int my_rename(const char *from,const char *to,myf MyFlags);
|
||||
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
|
||||
extern my_off_t my_tell(File fd,myf MyFlags);
|
||||
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
|
||||
myf MyFlags);
|
||||
extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
|
||||
my_off_t offset,myf MyFlags);
|
||||
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
|
||||
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
|
||||
myf MyFlags);
|
||||
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
|
||||
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
|
||||
|
||||
/* implemented in my_syslog.c */
|
||||
|
||||
// Maximum size of message that will be logged.
|
||||
#define MAX_SYSLOG_MESSAGE_SIZE 1024
|
||||
|
||||
/* Platform-independent SysLog support */
|
||||
|
||||
/* facilities on unixoid syslog. harmless on systemd / Win platforms. */
|
||||
typedef struct st_syslog_facility { int id; const char *name; } SYSLOG_FACILITY;
|
||||
extern SYSLOG_FACILITY syslog_facility[];
|
||||
|
||||
enum my_syslog_options { MY_SYSLOG_PIDS= 1 };
|
||||
|
||||
int my_openlog(const char *eventSourceName, int option, int facility);
|
||||
int my_closelog();
|
||||
int my_syslog(const CHARSET_INFO *cs, enum loglevel level, const char *msg);
|
||||
|
||||
/* implemented in my_memmem.c */
|
||||
extern void *my_memmem(const void *haystack, size_t haystacklen,
|
||||
const void *needle, size_t needlelen);
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
extern int my_access(const char *path, int amode);
|
||||
#else
|
||||
#define my_access access
|
||||
#endif
|
||||
|
||||
extern int check_if_legal_filename(const char *path);
|
||||
extern int check_if_legal_tablename(const char *path);
|
||||
|
||||
#ifdef _WIN32
|
||||
extern my_bool is_filename_allowed(const char *name, size_t length,
|
||||
my_bool allow_current_dir);
|
||||
#else /* _WIN32 */
|
||||
# define is_filename_allowed(name, length, allow_cwd) (TRUE)
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifdef _WIN32
|
||||
extern int nt_share_delete(const char *name,myf MyFlags);
|
||||
#define my_delete_allow_opened(fname,flags) nt_share_delete((fname),(flags))
|
||||
#else
|
||||
#define my_delete_allow_opened(fname,flags) my_delete((fname),(flags))
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
/* Windows-only functions (CRT equivalents)*/
|
||||
extern HANDLE my_get_osfhandle(File fd);
|
||||
extern void my_osmaperr(unsigned long last_error);
|
||||
#endif
|
||||
|
||||
extern const char* get_global_errmsg(int nr);
|
||||
extern void wait_for_free_space(const char *filename, int errors);
|
||||
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
|
||||
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
|
||||
extern FILE *my_freopen(const char *path, const char *mode, FILE *stream);
|
||||
extern int my_fclose(FILE *fd,myf MyFlags);
|
||||
extern File my_fileno(FILE *fd);
|
||||
extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags);
|
||||
extern void thr_set_sync_wait_callback(void (*before_sync)(void),
|
||||
void (*after_sync)(void));
|
||||
extern int my_sync(File fd, myf my_flags);
|
||||
extern int my_sync_dir(const char *dir_name, myf my_flags);
|
||||
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
|
||||
extern char *my_strerror(char *buf, size_t len, int errnum);
|
||||
extern const char *my_get_err_msg(int nr);
|
||||
extern void my_error(int nr,myf MyFlags, ...);
|
||||
extern void my_printf_error(uint my_err, const char *format,
|
||||
myf MyFlags, ...)
|
||||
MY_ATTRIBUTE((format(printf, 2, 4)));
|
||||
extern void my_printv_error(uint error, const char *format, myf MyFlags,
|
||||
va_list ap);
|
||||
extern int my_error_register(const char* (*get_errmsg) (int),
|
||||
int first, int last);
|
||||
extern my_bool my_error_unregister(int first, int last);
|
||||
extern void my_message(uint my_err, const char *str,myf MyFlags);
|
||||
extern void my_message_stderr(uint my_err, const char *str, myf MyFlags);
|
||||
void my_message_local_stderr(enum loglevel ll,
|
||||
const char *format, va_list args);
|
||||
extern void my_message_local(enum loglevel ll, const char *format, ...);
|
||||
extern my_bool my_init(void);
|
||||
extern void my_end(int infoflag);
|
||||
extern int my_redel(const char *from, const char *to, int MyFlags);
|
||||
extern int my_copystat(const char *from, const char *to, int MyFlags);
|
||||
extern char * my_filename(File fd);
|
||||
extern MY_MODE get_file_perm(ulong perm_flags);
|
||||
extern my_bool my_chmod(const char *filename, ulong perm_flags, myf my_flags);
|
||||
|
||||
#ifdef EXTRA_DEBUG
|
||||
void my_print_open_files(void);
|
||||
#else
|
||||
#define my_print_open_files()
|
||||
#endif
|
||||
|
||||
extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
|
||||
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
|
||||
extern void free_tmpdir(MY_TMPDIR *tmpdir);
|
||||
|
||||
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
|
||||
extern size_t dirname_length(const char *name);
|
||||
#define base_name(A) (A+dirname_length(A))
|
||||
extern int test_if_hard_path(const char *dir_name);
|
||||
extern my_bool has_path(const char *name);
|
||||
extern char *convert_dirname(char *to, const char *from, const char *from_end);
|
||||
extern void to_unix_path(char * name);
|
||||
extern char * fn_ext(const char *name);
|
||||
extern char * fn_same(char * toname,const char *name,int flag);
|
||||
extern char * fn_format(char * to,const char *name,const char *dir,
|
||||
const char *form, uint flag);
|
||||
extern size_t strlength(const char *str);
|
||||
extern void pack_dirname(char * to,const char *from);
|
||||
extern size_t normalize_dirname(char * to, const char *from);
|
||||
extern size_t unpack_dirname(char * to,const char *from);
|
||||
extern size_t cleanup_dirname(char * to,const char *from);
|
||||
extern size_t system_filename(char * to,const char *from);
|
||||
extern size_t unpack_filename(char * to,const char *from);
|
||||
extern char * intern_filename(char * to,const char *from);
|
||||
extern int pack_filename(char * to, const char *name, size_t max_length);
|
||||
extern char * my_path(char * to,const char *progname,
|
||||
const char *own_pathname_part);
|
||||
extern char * my_load_path(char * to, const char *path,
|
||||
const char *own_path_prefix);
|
||||
extern int wild_compare(const char *str,const char *wildstr,
|
||||
pbool str_is_pattern);
|
||||
extern my_bool array_append_string_unique(const char *str,
|
||||
const char **array, size_t size);
|
||||
extern void get_date(char * to,int timeflag,time_t use_time);
|
||||
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
|
||||
pbool remove_garbage);
|
||||
|
||||
extern my_bool radixsort_is_appliccable(uint n_items, size_t size_of_element);
|
||||
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
|
||||
size_t size_of_element,uchar *buffer[]);
|
||||
extern void my_qsort(void *base_ptr, size_t total_elems, size_t size,
|
||||
qsort_cmp cmp);
|
||||
extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size,
|
||||
qsort2_cmp cmp, const void *cmp_argument);
|
||||
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
|
||||
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
|
||||
extern int init_io_cache_ext(IO_CACHE *info,File file,size_t cachesize,
|
||||
enum cache_type type,my_off_t seek_offset,
|
||||
pbool use_async_io, myf cache_myflags,
|
||||
PSI_file_key file_key);
|
||||
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
|
||||
enum cache_type type,my_off_t seek_offset,
|
||||
pbool use_async_io, myf cache_myflags);
|
||||
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
|
||||
my_off_t seek_offset,pbool use_async_io,
|
||||
pbool clear_cache);
|
||||
extern void setup_io_cache(IO_CACHE* info);
|
||||
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
|
||||
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
|
||||
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
|
||||
IO_CACHE *write_cache, uint num_threads);
|
||||
extern void remove_io_thread(IO_CACHE *info);
|
||||
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
|
||||
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
|
||||
extern int _my_b_get(IO_CACHE *info);
|
||||
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
|
||||
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
|
||||
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
|
||||
|
||||
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
|
||||
size_t Count, my_off_t pos);
|
||||
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
|
||||
|
||||
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
|
||||
|
||||
extern int end_io_cache(IO_CACHE *info);
|
||||
extern size_t my_b_fill(IO_CACHE *info);
|
||||
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
|
||||
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
|
||||
extern my_off_t my_b_filelength(IO_CACHE *info);
|
||||
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...)
|
||||
MY_ATTRIBUTE((format(printf, 2, 3)));
|
||||
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
|
||||
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
|
||||
const char *prefix, size_t cache_size,
|
||||
myf cache_myflags);
|
||||
extern my_bool real_open_cached_file(IO_CACHE *cache);
|
||||
extern void close_cached_file(IO_CACHE *cache);
|
||||
File create_temp_file(char *to, const char *dir, const char *pfx,
|
||||
int mode, myf MyFlags);
|
||||
|
||||
// Use Prealloced_array or std::vector or something similar in C++
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern my_bool my_init_dynamic_array(DYNAMIC_ARRAY *array,
|
||||
PSI_memory_key key,
|
||||
uint element_size,
|
||||
void *init_buffer,
|
||||
uint init_alloc,
|
||||
uint alloc_increment);
|
||||
/* init_dynamic_array() function is deprecated */
|
||||
extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
|
||||
uint init_alloc, uint alloc_increment);
|
||||
#define dynamic_element(array,array_index,type) \
|
||||
((type)((array)->buffer) +(array_index))
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Some functions are still in use in C++, because HASH uses DYNAMIC_ARRAY */
|
||||
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void *element);
|
||||
extern void *alloc_dynamic(DYNAMIC_ARRAY *array);
|
||||
extern void *pop_dynamic(DYNAMIC_ARRAY*);
|
||||
extern void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint array_index);
|
||||
extern void claim_dynamic(DYNAMIC_ARRAY *array);
|
||||
extern void delete_dynamic(DYNAMIC_ARRAY *array);
|
||||
extern void freeze_size(DYNAMIC_ARRAY *array);
|
||||
static inline void reset_dynamic(DYNAMIC_ARRAY *array)
|
||||
{
|
||||
array->elements= 0;
|
||||
}
|
||||
|
||||
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
|
||||
size_t init_alloc,size_t alloc_increment);
|
||||
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
|
||||
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
|
||||
size_t length);
|
||||
extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
|
||||
...);
|
||||
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
|
||||
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
|
||||
extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
|
||||
extern void dynstr_free(DYNAMIC_STRING *str);
|
||||
#define alloc_root_inited(A) ((A)->min_malloc != 0)
|
||||
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
|
||||
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
|
||||
extern void init_alloc_root(PSI_memory_key key,
|
||||
MEM_ROOT *mem_root, size_t block_size,
|
||||
size_t pre_alloc_size);
|
||||
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
|
||||
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
|
||||
extern void claim_root(MEM_ROOT *root);
|
||||
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
|
||||
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
|
||||
size_t prealloc_size);
|
||||
extern char *strdup_root(MEM_ROOT *root,const char *str);
|
||||
static inline char *safe_strdup_root(MEM_ROOT *root, const char *str)
|
||||
{
|
||||
return str ? strdup_root(root, str) : 0;
|
||||
}
|
||||
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
|
||||
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
|
||||
extern void set_memroot_max_capacity(MEM_ROOT *mem_root, size_t size);
|
||||
extern void set_memroot_error_reporting(MEM_ROOT *mem_root,
|
||||
my_bool report_error);
|
||||
extern my_bool my_compress(uchar *, size_t *, size_t *);
|
||||
extern my_bool my_uncompress(uchar *, size_t , size_t *);
|
||||
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
|
||||
size_t *complen);
|
||||
extern int packfrm(uchar *, size_t, uchar **, size_t *);
|
||||
extern int unpackfrm(uchar **, size_t *, const uchar *);
|
||||
|
||||
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
|
||||
size_t count);
|
||||
|
||||
/* Wait a given number of microseconds */
|
||||
static inline void my_sleep(time_t m_seconds)
|
||||
{
|
||||
#if defined(_WIN32)
|
||||
Sleep((DWORD)m_seconds/1000+1); /* Sleep() has millisecond arg */
|
||||
#else
|
||||
struct timeval t;
|
||||
t.tv_sec= m_seconds / 1000000L;
|
||||
t.tv_usec= m_seconds % 1000000L;
|
||||
select(0,0,0,0,&t); /* sleep */
|
||||
#endif
|
||||
}
|
||||
|
||||
extern ulong crc32(ulong crc, const uchar *buf, uint len);
|
||||
extern uint my_set_max_open_files(uint files);
|
||||
void my_free_open_file_info(void);
|
||||
|
||||
extern time_t my_time(myf flags);
|
||||
extern ulonglong my_getsystime(void);
|
||||
extern ulonglong my_micro_time();
|
||||
extern my_bool my_gethwaddr(uchar *to);
|
||||
|
||||
#ifdef HAVE_SYS_MMAN_H
|
||||
#include <sys/mman.h>
|
||||
|
||||
#ifndef MAP_NOSYNC
|
||||
#define MAP_NOSYNC 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
Not defined in FreeBSD 11.
|
||||
Was never implemented in FreeBSD, so we just set it to 0.
|
||||
*/
|
||||
#ifndef MAP_NORESERVE
|
||||
#define MAP_NORESERVE 0
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_MMAP64
|
||||
#define my_mmap(a,b,c,d,e,f) mmap64(a,b,c,d,e,f)
|
||||
#else
|
||||
#define my_mmap(a,b,c,d,e,f) mmap(a,b,c,d,e,f)
|
||||
#endif
|
||||
#define my_munmap(a,b) munmap((a),(b))
|
||||
|
||||
#else
|
||||
/* not a complete set of mmap() flags, but only those that nesessary */
|
||||
#define PROT_READ 1
|
||||
#define PROT_WRITE 2
|
||||
#define MAP_NORESERVE 0
|
||||
#define MAP_SHARED 0x0001
|
||||
#define MAP_PRIVATE 0x0002
|
||||
#define MAP_NOSYNC 0x0800
|
||||
#define MAP_FAILED ((void *)-1)
|
||||
#define MS_SYNC 0x0000
|
||||
|
||||
void *my_mmap(void *, size_t, int, int, int, my_off_t);
|
||||
int my_munmap(void *, size_t);
|
||||
#endif
|
||||
|
||||
/* my_getpagesize */
|
||||
static inline int my_getpagesize()
|
||||
{
|
||||
#ifndef _WIN32
|
||||
return getpagesize();
|
||||
#else
|
||||
SYSTEM_INFO si;
|
||||
GetSystemInfo(&si);
|
||||
return (int)si.dwPageSize;
|
||||
#endif
|
||||
}
|
||||
|
||||
int my_msync(int, void *, size_t, int);
|
||||
|
||||
/* character sets */
|
||||
extern void my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader);
|
||||
extern uint get_charset_number(const char *cs_name, uint cs_flags);
|
||||
extern uint get_collation_number(const char *name);
|
||||
extern const char *get_charset_name(uint cs_number);
|
||||
|
||||
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
|
||||
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
|
||||
extern CHARSET_INFO *my_collation_get_by_name(MY_CHARSET_LOADER *loader,
|
||||
const char *name, myf flags);
|
||||
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
|
||||
uint cs_flags, myf my_flags);
|
||||
extern CHARSET_INFO *my_charset_get_by_name(MY_CHARSET_LOADER *loader,
|
||||
const char *name,
|
||||
uint cs_flags, myf my_flags);
|
||||
extern my_bool resolve_charset(const char *cs_name,
|
||||
const CHARSET_INFO *default_cs,
|
||||
const CHARSET_INFO **cs);
|
||||
extern my_bool resolve_collation(const char *cl_name,
|
||||
const CHARSET_INFO *default_cl,
|
||||
const CHARSET_INFO **cl);
|
||||
extern void free_charsets(void);
|
||||
extern char *get_charsets_dir(char *buf);
|
||||
extern my_bool my_charset_same(const CHARSET_INFO *cs1,
|
||||
const CHARSET_INFO *cs2);
|
||||
extern my_bool init_compiled_charsets(myf flags);
|
||||
extern void add_compiled_collation(CHARSET_INFO *cs);
|
||||
extern size_t escape_string_for_mysql(const CHARSET_INFO *charset_info,
|
||||
char *to, size_t to_length,
|
||||
const char *from, size_t length);
|
||||
#ifdef _WIN32
|
||||
/* File system character set */
|
||||
extern CHARSET_INFO *fs_character_set(void);
|
||||
#endif
|
||||
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
|
||||
char *to, size_t to_length,
|
||||
const char *from, size_t length, char quote);
|
||||
#ifdef _WIN32
|
||||
extern my_bool have_tcpip; /* Is set if tcpip is used */
|
||||
|
||||
/* implemented in my_windac.c */
|
||||
|
||||
int my_security_attr_create(SECURITY_ATTRIBUTES **psa, const char **perror,
|
||||
DWORD owner_rights, DWORD everybody_rights);
|
||||
|
||||
void my_security_attr_free(SECURITY_ATTRIBUTES *sa);
|
||||
|
||||
/* implemented in my_conio.c */
|
||||
my_bool my_win_is_console(FILE *file);
|
||||
char *my_win_console_readline(const CHARSET_INFO *cs, char *mbbuf, size_t mbbufsize,
|
||||
size_t *nread);
|
||||
void my_win_console_write(const CHARSET_INFO *cs, const char *data, size_t datalen);
|
||||
void my_win_console_fputs(const CHARSET_INFO *cs, const char *data);
|
||||
void my_win_console_putc(const CHARSET_INFO *cs, int c);
|
||||
void my_win_console_vfprintf(const CHARSET_INFO *cs, const char *fmt, va_list args);
|
||||
int my_win_translate_command_line_args(const CHARSET_INFO *cs, int *ac, char ***av);
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
extern MYSQL_PLUGIN_IMPORT struct PSI_bootstrap *PSI_hook;
|
||||
extern void set_psi_server(PSI *psi);
|
||||
void my_init_mysys_psi_keys(void);
|
||||
#endif
|
||||
|
||||
struct st_mysql_file;
|
||||
extern struct st_mysql_file *mysql_stdin;
|
||||
|
||||
C_MODE_END
|
||||
#endif /* _my_sys_h */
|
|
@ -0,0 +1,199 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
|
||||
|
||||
/* Defines to make different thread packages compatible */
|
||||
|
||||
#ifndef MY_THREAD_INCLUDED
|
||||
#define MY_THREAD_INCLUDED
|
||||
|
||||
#include "my_global.h" /* my_bool */
|
||||
|
||||
#if !defined(_WIN32)
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
#ifndef ETIME
|
||||
#define ETIME ETIMEDOUT /* For FreeBSD */
|
||||
#endif
|
||||
|
||||
#ifndef ETIMEDOUT
|
||||
#define ETIMEDOUT 145 /* Win32 doesn't have this */
|
||||
#endif
|
||||
|
||||
/*
|
||||
MySQL can survive with 32K, but some glibc libraries require > 128K stack
|
||||
To resolve hostnames. Also recursive stored procedures needs stack.
|
||||
*/
|
||||
#if defined(__sparc) && (defined(__SUNPRO_CC) || defined(__SUNPRO_C))
|
||||
#define STACK_MULTIPLIER 2UL
|
||||
#else
|
||||
#define STACK_MULTIPLIER 1UL
|
||||
#endif
|
||||
|
||||
#if SIZEOF_CHARP > 4
|
||||
#define DEFAULT_THREAD_STACK (STACK_MULTIPLIER * 256UL * 1024UL)
|
||||
#else
|
||||
#define DEFAULT_THREAD_STACK (STACK_MULTIPLIER * 192UL * 1024UL)
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define EXTERNC extern "C"
|
||||
#else
|
||||
#define EXTERNC
|
||||
#endif
|
||||
|
||||
C_MODE_START
|
||||
|
||||
#ifdef _WIN32
|
||||
typedef volatile LONG my_thread_once_t;
|
||||
typedef DWORD my_thread_t;
|
||||
typedef struct thread_attr
|
||||
{
|
||||
DWORD dwStackSize;
|
||||
int detachstate;
|
||||
} my_thread_attr_t;
|
||||
#define MY_THREAD_CREATE_JOINABLE 0
|
||||
#define MY_THREAD_CREATE_DETACHED 1
|
||||
typedef void * (__cdecl *my_start_routine)(void *);
|
||||
#define MY_THREAD_ONCE_INIT 0
|
||||
#define MY_THREAD_ONCE_INPROGRESS 1
|
||||
#define MY_THREAD_ONCE_DONE 2
|
||||
#else
|
||||
typedef pthread_once_t my_thread_once_t;
|
||||
typedef pthread_t my_thread_t;
|
||||
typedef pthread_attr_t my_thread_attr_t;
|
||||
#define MY_THREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
|
||||
#define MY_THREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
|
||||
typedef void *(* my_start_routine)(void *);
|
||||
#define MY_THREAD_ONCE_INIT PTHREAD_ONCE_INIT
|
||||
#endif
|
||||
|
||||
typedef struct st_my_thread_handle
|
||||
{
|
||||
my_thread_t thread;
|
||||
#ifdef _WIN32
|
||||
HANDLE handle;
|
||||
#endif
|
||||
} my_thread_handle;
|
||||
|
||||
int my_thread_once(my_thread_once_t *once_control, void (*init_routine)(void));
|
||||
|
||||
static inline my_thread_t my_thread_self()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return GetCurrentThreadId();
|
||||
#else
|
||||
return pthread_self();
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_thread_equal(my_thread_t t1, my_thread_t t2)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return t1 == t2;
|
||||
#else
|
||||
return pthread_equal(t1, t2);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_thread_attr_init(my_thread_attr_t *attr)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
attr->dwStackSize= 0;
|
||||
/* Set to joinable by default to match Linux */
|
||||
attr->detachstate= MY_THREAD_CREATE_JOINABLE;
|
||||
return 0;
|
||||
#else
|
||||
return pthread_attr_init(attr);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_thread_attr_destroy(my_thread_attr_t *attr)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
attr->dwStackSize= 0;
|
||||
/* Set to joinable by default to match Linux */
|
||||
attr->detachstate= MY_THREAD_CREATE_JOINABLE;
|
||||
return 0;
|
||||
#else
|
||||
return pthread_attr_destroy(attr);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_thread_attr_setstacksize(my_thread_attr_t *attr,
|
||||
size_t stacksize)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
attr->dwStackSize= (DWORD)stacksize;
|
||||
return 0;
|
||||
#else
|
||||
return pthread_attr_setstacksize(attr, stacksize);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_thread_attr_setdetachstate(my_thread_attr_t *attr,
|
||||
int detachstate)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
attr->detachstate= detachstate;
|
||||
return 0;
|
||||
#else
|
||||
return pthread_attr_setdetachstate(attr, detachstate);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_thread_attr_getstacksize(my_thread_attr_t *attr,
|
||||
size_t *stacksize)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
*stacksize= (size_t)attr->dwStackSize;
|
||||
return 0;
|
||||
#else
|
||||
return pthread_attr_getstacksize(attr, stacksize);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void my_thread_yield()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SwitchToThread();
|
||||
#else
|
||||
sched_yield();
|
||||
#endif
|
||||
}
|
||||
|
||||
int my_thread_create(my_thread_handle *thread, const my_thread_attr_t *attr,
|
||||
my_start_routine func, void *arg);
|
||||
int my_thread_join(my_thread_handle *thread, void **value_ptr);
|
||||
int my_thread_cancel(my_thread_handle *thread);
|
||||
void my_thread_exit(void *value_ptr);
|
||||
|
||||
|
||||
extern my_bool my_thread_global_init();
|
||||
extern void my_thread_global_reinit();
|
||||
extern void my_thread_global_end();
|
||||
extern my_bool my_thread_init();
|
||||
extern void my_thread_end();
|
||||
|
||||
C_MODE_END
|
||||
|
||||
#endif /* MY_THREAD_INCLUDED */
|
|
@ -0,0 +1,114 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
|
||||
|
||||
#ifndef MY_THREAD_LOCAL_INCLUDED
|
||||
#define MY_THREAD_LOCAL_INCLUDED
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
struct _db_code_state_;
|
||||
typedef uint32 my_thread_id;
|
||||
|
||||
C_MODE_START
|
||||
|
||||
#ifdef _WIN32
|
||||
typedef DWORD thread_local_key_t;
|
||||
#else
|
||||
typedef pthread_key_t thread_local_key_t;
|
||||
#endif
|
||||
|
||||
static inline int my_create_thread_local_key(thread_local_key_t *key,
|
||||
void (*destructor)(void *))
|
||||
{
|
||||
#ifdef _WIN32
|
||||
*key= TlsAlloc();
|
||||
return (*key == TLS_OUT_OF_INDEXES);
|
||||
#else
|
||||
return pthread_key_create(key, destructor);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_delete_thread_local_key(thread_local_key_t key)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return !TlsFree(key);
|
||||
#else
|
||||
return pthread_key_delete(key);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void* my_get_thread_local(thread_local_key_t key)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return TlsGetValue(key);
|
||||
#else
|
||||
return pthread_getspecific(key);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int my_set_thread_local(thread_local_key_t key,
|
||||
void *value)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return !TlsSetValue(key, value);
|
||||
#else
|
||||
return pthread_setspecific(key, value);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Retrieve the MySQL thread-local storage variant of errno.
|
||||
*/
|
||||
int my_errno();
|
||||
|
||||
/**
|
||||
Set the MySQL thread-local storage variant of errno.
|
||||
*/
|
||||
void set_my_errno(int my_errno);
|
||||
|
||||
#ifdef _WIN32
|
||||
/*
|
||||
thr_winerr is used for returning the original OS error-code in Windows,
|
||||
my_osmaperr() returns EINVAL for all unknown Windows errors, hence we
|
||||
preserve the original Windows Error code in thr_winerr.
|
||||
*/
|
||||
int thr_winerr();
|
||||
|
||||
void set_thr_winerr(int winerr);
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef NDEBUG
|
||||
/* Return pointer to DBUG for holding current state */
|
||||
struct _db_code_state_ **my_thread_var_dbug();
|
||||
|
||||
my_thread_id my_thread_var_id();
|
||||
|
||||
void set_my_thread_var_id(my_thread_id id);
|
||||
|
||||
#endif
|
||||
|
||||
C_MODE_END
|
||||
|
||||
#endif // MY_THREAD_LOCAL_INCLUDED
|
|
@ -0,0 +1,103 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
|
||||
|
||||
|
||||
#ifndef _my_xml_h
|
||||
#define _my_xml_h
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#define MY_XML_OK 0
|
||||
#define MY_XML_ERROR 1
|
||||
|
||||
/*
|
||||
A flag whether to use absolute tag names in call-back functions,
|
||||
like "a", "a.b" and "a.b.c" (used in character set file parser),
|
||||
or relative names like "a", "b" and "c".
|
||||
*/
|
||||
#define MY_XML_FLAG_RELATIVE_NAMES 1
|
||||
|
||||
/*
|
||||
A flag whether to skip normilization of text values before calling
|
||||
call-back functions: i.e. skip leading/trailing spaces,
|
||||
\r, \n, \t characters.
|
||||
*/
|
||||
#define MY_XML_FLAG_SKIP_TEXT_NORMALIZATION 2
|
||||
|
||||
enum my_xml_node_type
|
||||
{
|
||||
MY_XML_NODE_TAG, /* can have TAG, ATTR and TEXT children */
|
||||
MY_XML_NODE_ATTR, /* can have TEXT children */
|
||||
MY_XML_NODE_TEXT /* cannot have children */
|
||||
};
|
||||
|
||||
typedef struct xml_stack_st
|
||||
{
|
||||
int flags;
|
||||
enum my_xml_node_type current_node_type;
|
||||
char errstr[128];
|
||||
|
||||
struct {
|
||||
char static_buffer[128];
|
||||
char *buffer;
|
||||
size_t buffer_size;
|
||||
char *start;
|
||||
char *end;
|
||||
} attr;
|
||||
|
||||
const char *beg;
|
||||
const char *cur;
|
||||
const char *end;
|
||||
void *user_data;
|
||||
int (*enter)(struct xml_stack_st *st,const char *val, size_t len);
|
||||
int (*value)(struct xml_stack_st *st,const char *val, size_t len);
|
||||
int (*leave_xml)(struct xml_stack_st *st,const char *val, size_t len);
|
||||
} MY_XML_PARSER;
|
||||
|
||||
void my_xml_parser_create(MY_XML_PARSER *st);
|
||||
void my_xml_parser_free(MY_XML_PARSER *st);
|
||||
int my_xml_parse(MY_XML_PARSER *st,const char *str, size_t len);
|
||||
|
||||
void my_xml_set_value_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *,
|
||||
const char *,
|
||||
size_t len));
|
||||
void my_xml_set_enter_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *,
|
||||
const char *,
|
||||
size_t len));
|
||||
void my_xml_set_leave_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *,
|
||||
const char *,
|
||||
size_t len));
|
||||
void my_xml_set_user_data(MY_XML_PARSER *st, void *);
|
||||
|
||||
size_t my_xml_error_pos(MY_XML_PARSER *st);
|
||||
uint my_xml_error_lineno(MY_XML_PARSER *st);
|
||||
|
||||
const char *my_xml_error_string(MY_XML_PARSER *st);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _my_xml_h */
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,38 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
#ifndef CLIENT_AUTHENTICATION_H
|
||||
#define CLIENT_AUTHENTICATION_H
|
||||
#include <my_global.h>
|
||||
#include "mysql.h"
|
||||
#include "mysql/client_plugin.h"
|
||||
|
||||
C_MODE_START
|
||||
int sha256_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql);
|
||||
int sha256_password_init(char *, size_t, int, va_list);
|
||||
int sha256_password_deinit(void);
|
||||
int caching_sha2_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql);
|
||||
int caching_sha2_password_init(char *, size_t, int, va_list);
|
||||
int caching_sha2_password_deinit(void);
|
||||
C_MODE_END
|
||||
|
||||
#endif
|
||||
|
|
@ -27,8 +27,10 @@
|
|||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file include/mysql/client_plugin.h
|
||||
MySQL Client Plugin API.
|
||||
@file
|
||||
|
||||
MySQL Client Plugin API
|
||||
|
||||
This file defines the API for plugins that work on the client side
|
||||
*/
|
||||
#define MYSQL_CLIENT_PLUGIN_INCLUDED
|
||||
|
@ -49,87 +51,75 @@
|
|||
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(MYSQL_DYNAMIC_PLUGIN)
|
||||
#ifdef __cplusplus
|
||||
#define MYSQL_PLUGIN_EXPORT extern "C" __declspec(dllexport)
|
||||
#else
|
||||
#define MYSQL_PLUGIN_EXPORT __declspec(dllexport)
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
#define MYSQL_PLUGIN_EXPORT extern "C" __declspec(dllexport)
|
||||
#else
|
||||
#define MYSQL_PLUGIN_EXPORT __declspec(dllexport)
|
||||
#endif
|
||||
#else /* MYSQL_DYNAMIC_PLUGIN */
|
||||
#ifdef __cplusplus
|
||||
#define MYSQL_PLUGIN_EXPORT extern "C"
|
||||
#else
|
||||
#define MYSQL_PLUGIN_EXPORT
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
#define MYSQL_PLUGIN_EXPORT extern "C"
|
||||
#else
|
||||
#define MYSQL_PLUGIN_EXPORT
|
||||
#endif
|
||||
#endif /*MYSQL_DYNAMIC_PLUGIN */
|
||||
#else /*_MSC_VER */
|
||||
|
||||
#if defined(MYSQL_DYNAMIC_PLUGIN)
|
||||
#define MYSQL_PLUGIN_EXPORT MY_ATTRIBUTE((visibility("default")))
|
||||
#else
|
||||
#else /*_MSC_VER */
|
||||
#define MYSQL_PLUGIN_EXPORT
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* known plugin types */
|
||||
#define MYSQL_CLIENT_reserved1 0
|
||||
#define MYSQL_CLIENT_reserved2 1
|
||||
#define MYSQL_CLIENT_AUTHENTICATION_PLUGIN 2
|
||||
#define MYSQL_CLIENT_TRACE_PLUGIN 3
|
||||
#define MYSQL_CLIENT_reserved1 0
|
||||
#define MYSQL_CLIENT_reserved2 1
|
||||
#define MYSQL_CLIENT_AUTHENTICATION_PLUGIN 2
|
||||
#define MYSQL_CLIENT_TRACE_PLUGIN 3
|
||||
|
||||
#define MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION 0x0200
|
||||
#define MYSQL_CLIENT_TRACE_PLUGIN_INTERFACE_VERSION 0x0200
|
||||
#define MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION 0x0100
|
||||
#define MYSQL_CLIENT_TRACE_PLUGIN_INTERFACE_VERSION 0x0100
|
||||
|
||||
#define MYSQL_CLIENT_MAX_PLUGINS 4
|
||||
#define MYSQL_CLIENT_MAX_PLUGINS 4
|
||||
|
||||
#define MYSQL_CLIENT_PLUGIN_AUTHOR_ORACLE "Oracle Corporation"
|
||||
|
||||
#define mysql_declare_client_plugin(X) \
|
||||
MYSQL_PLUGIN_EXPORT st_mysql_client_plugin_##X \
|
||||
_mysql_client_plugin_declaration_ = { \
|
||||
MYSQL_CLIENT_##X##_PLUGIN, \
|
||||
MYSQL_CLIENT_##X##_PLUGIN_INTERFACE_VERSION,
|
||||
#define mysql_end_client_plugin }
|
||||
#define mysql_declare_client_plugin(X) \
|
||||
MYSQL_PLUGIN_EXPORT struct st_mysql_client_plugin_ ## X \
|
||||
_mysql_client_plugin_declaration_ = { \
|
||||
MYSQL_CLIENT_ ## X ## _PLUGIN, \
|
||||
MYSQL_CLIENT_ ## X ## _PLUGIN_INTERFACE_VERSION,
|
||||
#define mysql_end_client_plugin }
|
||||
|
||||
/* generic plugin header structure */
|
||||
#define MYSQL_CLIENT_PLUGIN_HEADER \
|
||||
int type; \
|
||||
unsigned int interface_version; \
|
||||
const char *name; \
|
||||
const char *author; \
|
||||
const char *desc; \
|
||||
unsigned int version[3]; \
|
||||
const char *license; \
|
||||
void *mysql_api; \
|
||||
int (*init)(char *, size_t, int, va_list); \
|
||||
int (*deinit)(void); \
|
||||
int (*options)(const char *option, const void *); \
|
||||
int (*get_options)(const char *option, void *);
|
||||
#define MYSQL_CLIENT_PLUGIN_HEADER \
|
||||
int type; \
|
||||
unsigned int interface_version; \
|
||||
const char *name; \
|
||||
const char *author; \
|
||||
const char *desc; \
|
||||
unsigned int version[3]; \
|
||||
const char *license; \
|
||||
void *mysql_api; \
|
||||
int (*init)(char *, size_t, int, va_list); \
|
||||
int (*deinit)(void); \
|
||||
int (*options)(const char *option, const void *);
|
||||
|
||||
struct st_mysql_client_plugin {
|
||||
struct st_mysql_client_plugin
|
||||
{
|
||||
MYSQL_CLIENT_PLUGIN_HEADER
|
||||
};
|
||||
|
||||
struct MYSQL;
|
||||
struct st_mysql;
|
||||
|
||||
/******** authentication plugin specific declarations *********/
|
||||
#include "plugin_auth_common.h"
|
||||
|
||||
struct auth_plugin_t {
|
||||
struct st_mysql_client_plugin_AUTHENTICATION
|
||||
{
|
||||
MYSQL_CLIENT_PLUGIN_HEADER
|
||||
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, struct MYSQL *mysql);
|
||||
enum net_async_status (*authenticate_user_nonblocking)(MYSQL_PLUGIN_VIO *vio,
|
||||
struct MYSQL *mysql,
|
||||
int *result);
|
||||
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, struct st_mysql *mysql);
|
||||
};
|
||||
|
||||
// Needed for the mysql_declare_client_plugin() macro. Do not use elsewhere.
|
||||
typedef struct auth_plugin_t st_mysql_client_plugin_AUTHENTICATION;
|
||||
|
||||
/******** using plugins ************/
|
||||
|
||||
/**
|
||||
|
@ -145,9 +135,9 @@ typedef struct auth_plugin_t st_mysql_client_plugin_AUTHENTICATION;
|
|||
@retval
|
||||
a pointer to the loaded plugin, or NULL in case of a failure
|
||||
*/
|
||||
struct st_mysql_client_plugin *mysql_load_plugin(struct MYSQL *mysql,
|
||||
const char *name, int type,
|
||||
int argc, ...);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_load_plugin(struct st_mysql *mysql, const char *name, int type,
|
||||
int argc, ...);
|
||||
|
||||
/**
|
||||
loads a plugin and initializes it, taking va_list as an argument
|
||||
|
@ -165,9 +155,9 @@ struct st_mysql_client_plugin *mysql_load_plugin(struct MYSQL *mysql,
|
|||
@retval
|
||||
a pointer to the loaded plugin, or NULL in case of a failure
|
||||
*/
|
||||
struct st_mysql_client_plugin *mysql_load_plugin_v(struct MYSQL *mysql,
|
||||
const char *name, int type,
|
||||
int argc, va_list args);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_load_plugin_v(struct st_mysql *mysql, const char *name, int type,
|
||||
int argc, va_list args);
|
||||
|
||||
/**
|
||||
finds an already loaded plugin by name, or loads it, if necessary
|
||||
|
@ -179,9 +169,8 @@ struct st_mysql_client_plugin *mysql_load_plugin_v(struct MYSQL *mysql,
|
|||
@retval
|
||||
a pointer to the plugin, or NULL in case of a failure
|
||||
*/
|
||||
struct st_mysql_client_plugin *mysql_client_find_plugin(struct MYSQL *mysql,
|
||||
const char *name,
|
||||
int type);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_client_find_plugin(struct st_mysql *mysql, const char *name, int type);
|
||||
|
||||
/**
|
||||
adds a plugin structure to the list of loaded plugins
|
||||
|
@ -197,8 +186,9 @@ struct st_mysql_client_plugin *mysql_client_find_plugin(struct MYSQL *mysql,
|
|||
@retval
|
||||
a pointer to the plugin, or NULL in case of a failure
|
||||
*/
|
||||
struct st_mysql_client_plugin *mysql_client_register_plugin(
|
||||
struct MYSQL *mysql, struct st_mysql_client_plugin *plugin);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_client_register_plugin(struct st_mysql *mysql,
|
||||
struct st_mysql_client_plugin *plugin);
|
||||
|
||||
/**
|
||||
set plugin options
|
||||
|
@ -215,23 +205,10 @@ struct st_mysql_client_plugin *mysql_client_register_plugin(
|
|||
int mysql_plugin_options(struct st_mysql_client_plugin *plugin,
|
||||
const char *option, const void *value);
|
||||
|
||||
/**
|
||||
get plugin options
|
||||
|
||||
Can be used to get options from a plugin.
|
||||
This function may be called multiple times to get several options
|
||||
|
||||
@param plugin an st_mysql_client_plugin structure
|
||||
@param option a string which specifies the option to get
|
||||
@param[out] value value for the option.
|
||||
|
||||
@retval 0 on success, 1 in case of failure
|
||||
**/
|
||||
int mysql_plugin_get_option(struct st_mysql_client_plugin *plugin,
|
||||
const char *option, void *value);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
@ -0,0 +1,39 @@
|
|||
struct st_mysql_client_plugin
|
||||
{
|
||||
int type; unsigned int interface_version; const char *name; const char *author; const char *desc; unsigned int version[3]; const char *license; void *mysql_api; int (*init)(char *, size_t, int, va_list); int (*deinit)(void); int (*options)(const char *option, const void *);
|
||||
};
|
||||
struct st_mysql;
|
||||
#include "plugin_auth_common.h"
|
||||
typedef struct st_plugin_vio_info
|
||||
{
|
||||
enum { MYSQL_VIO_INVALID, MYSQL_VIO_TCP, MYSQL_VIO_SOCKET,
|
||||
MYSQL_VIO_PIPE, MYSQL_VIO_MEMORY } protocol;
|
||||
int socket;
|
||||
} MYSQL_PLUGIN_VIO_INFO;
|
||||
typedef struct st_plugin_vio
|
||||
{
|
||||
int (*read_packet)(struct st_plugin_vio *vio,
|
||||
unsigned char **buf);
|
||||
int (*write_packet)(struct st_plugin_vio *vio,
|
||||
const unsigned char *packet,
|
||||
int packet_len);
|
||||
void (*info)(struct st_plugin_vio *vio, struct st_plugin_vio_info *info);
|
||||
} MYSQL_PLUGIN_VIO;
|
||||
struct st_mysql_client_plugin_AUTHENTICATION
|
||||
{
|
||||
int type; unsigned int interface_version; const char *name; const char *author; const char *desc; unsigned int version[3]; const char *license; void *mysql_api; int (*init)(char *, size_t, int, va_list); int (*deinit)(void); int (*options)(const char *option, const void *);
|
||||
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, struct st_mysql *mysql);
|
||||
};
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_load_plugin(struct st_mysql *mysql, const char *name, int type,
|
||||
int argc, ...);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_load_plugin_v(struct st_mysql *mysql, const char *name, int type,
|
||||
int argc, va_list args);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_client_find_plugin(struct st_mysql *mysql, const char *name, int type);
|
||||
struct st_mysql_client_plugin *
|
||||
mysql_client_register_plugin(struct st_mysql *mysql,
|
||||
struct st_mysql_client_plugin *plugin);
|
||||
int mysql_plugin_options(struct st_mysql_client_plugin *plugin,
|
||||
const char *option, const void *value);
|
|
@ -0,0 +1,132 @@
|
|||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc., 51
|
||||
Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
#ifndef PLUGIN_PROTOCOL_INCLUDED
|
||||
#define PLUGIN_PROTOCOL_INCLUDED
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include "my_global.h" /* Needed for my_bool in mysql_com.h */
|
||||
#include "mysql_com.h" /* mysql_enum_shutdown_level */
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
@file
|
||||
Definition of COM_DATA to be used with the Command service as data input
|
||||
structure.
|
||||
*/
|
||||
|
||||
|
||||
typedef struct st_com_init_db_data
|
||||
{
|
||||
const char *db_name;
|
||||
unsigned long length;
|
||||
} COM_INIT_DB_DATA;
|
||||
|
||||
typedef struct st_com_refresh_data
|
||||
{
|
||||
unsigned char options;
|
||||
} COM_REFRESH_DATA;
|
||||
|
||||
typedef struct st_com_shutdown_data
|
||||
{
|
||||
enum mysql_enum_shutdown_level level;
|
||||
} COM_SHUTDOWN_DATA;
|
||||
|
||||
typedef struct st_com_kill_data
|
||||
{
|
||||
unsigned long id;
|
||||
} COM_KILL_DATA;
|
||||
|
||||
typedef struct st_com_set_option_data
|
||||
{
|
||||
unsigned int opt_command;
|
||||
} COM_SET_OPTION_DATA;
|
||||
|
||||
typedef struct st_com_stmt_execute_data
|
||||
{
|
||||
unsigned long stmt_id;
|
||||
unsigned long flags;
|
||||
unsigned char *params;
|
||||
unsigned long params_length;
|
||||
} COM_STMT_EXECUTE_DATA;
|
||||
|
||||
typedef struct st_com_stmt_fetch_data
|
||||
{
|
||||
unsigned long stmt_id;
|
||||
unsigned long num_rows;
|
||||
} COM_STMT_FETCH_DATA;
|
||||
|
||||
typedef struct st_com_stmt_send_long_data_data
|
||||
{
|
||||
unsigned long stmt_id;
|
||||
unsigned int param_number;
|
||||
unsigned char *longdata;
|
||||
unsigned long length;
|
||||
} COM_STMT_SEND_LONG_DATA_DATA;
|
||||
|
||||
typedef struct st_com_stmt_prepare_data
|
||||
{
|
||||
const char *query;
|
||||
unsigned int length;
|
||||
} COM_STMT_PREPARE_DATA;
|
||||
|
||||
typedef struct st_stmt_close_data
|
||||
{
|
||||
unsigned int stmt_id;
|
||||
} COM_STMT_CLOSE_DATA;
|
||||
|
||||
typedef struct st_com_stmt_reset_data
|
||||
{
|
||||
unsigned int stmt_id;
|
||||
} COM_STMT_RESET_DATA;
|
||||
|
||||
typedef struct st_com_query_data
|
||||
{
|
||||
const char *query;
|
||||
unsigned int length;
|
||||
} COM_QUERY_DATA;
|
||||
|
||||
typedef struct st_com_field_list_data
|
||||
{
|
||||
unsigned char *table_name;
|
||||
unsigned int table_name_length;
|
||||
const unsigned char *query;
|
||||
unsigned int query_length;
|
||||
} COM_FIELD_LIST_DATA;
|
||||
|
||||
union COM_DATA {
|
||||
COM_INIT_DB_DATA com_init_db;
|
||||
COM_REFRESH_DATA com_refresh;
|
||||
COM_SHUTDOWN_DATA com_shutdown;
|
||||
COM_KILL_DATA com_kill;
|
||||
COM_SET_OPTION_DATA com_set_option;
|
||||
COM_STMT_EXECUTE_DATA com_stmt_execute;
|
||||
COM_STMT_FETCH_DATA com_stmt_fetch;
|
||||
COM_STMT_SEND_LONG_DATA_DATA com_stmt_send_long_data;
|
||||
COM_STMT_PREPARE_DATA com_stmt_prepare;
|
||||
COM_STMT_CLOSE_DATA com_stmt_close;
|
||||
COM_STMT_RESET_DATA com_stmt_reset;
|
||||
COM_QUERY_DATA com_query;
|
||||
COM_FIELD_LIST_DATA com_field_list;
|
||||
};
|
||||
|
||||
#endif /* PLUGIN_PROTOCOL_INCLUDED */
|
|
@ -0,0 +1,43 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
** Ask for a password from tty
|
||||
** This is an own file to avoid conflicts with curses
|
||||
*/
|
||||
|
||||
#ifndef MYSQL_GET_PASSWORD_H_INCLUDED
|
||||
#define MYSQL_GET_PASSWORD_H_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef char *(* strdup_handler_t)(const char *, int);
|
||||
char *get_tty_password_ext(const char *opt_message,
|
||||
strdup_handler_t strdup_function);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ! MYSQL_GET_PASSWORD_H_INCLUDED */
|
|
@ -0,0 +1,206 @@
|
|||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef GROUP_REPLICATION_PRIV_INCLUDE
|
||||
#define GROUP_REPLICATION_PRIV_INCLUDE
|
||||
|
||||
#ifndef MYSQL_SERVER
|
||||
#define MYSQL_SERVER
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_REPLICATION
|
||||
#define HAVE_REPLICATION
|
||||
#endif
|
||||
|
||||
#include <my_global.h>
|
||||
#include <my_thread.h>
|
||||
#include <my_sys.h>
|
||||
|
||||
#include <debug_sync.h>
|
||||
#include <log_event.h>
|
||||
#include <replication.h>
|
||||
#include <rpl_channel_service_interface.h>
|
||||
#include <rpl_gtid.h>
|
||||
#include <rpl_write_set_handler.h>
|
||||
|
||||
|
||||
/**
|
||||
Server side initializations.
|
||||
*/
|
||||
int group_replication_init();
|
||||
|
||||
|
||||
/**
|
||||
Returns the server connection attribute
|
||||
|
||||
@Note This method implementation is on sql_class.cc
|
||||
|
||||
@return the pthread for the connection attribute.
|
||||
*/
|
||||
my_thread_attr_t *get_connection_attrib();
|
||||
|
||||
/**
|
||||
Returns the server hostname, port and uuid.
|
||||
|
||||
@param[out] hostname
|
||||
@param[out] port
|
||||
@param[out] uuid
|
||||
@param[out] server_version
|
||||
@param[out] server_ssl_variables
|
||||
|
||||
*/
|
||||
void get_server_parameters(char **hostname, uint *port, char **uuid,
|
||||
unsigned int *server_version,
|
||||
st_server_ssl_variables* server_ssl_variables);
|
||||
|
||||
/**
|
||||
Returns the server_id.
|
||||
|
||||
@return server_id
|
||||
*/
|
||||
ulong get_server_id();
|
||||
|
||||
/**
|
||||
Returns the server auto_increment_increment
|
||||
|
||||
@return auto_increment_increment
|
||||
*/
|
||||
ulong get_auto_increment_increment();
|
||||
|
||||
|
||||
/**
|
||||
Returns the server auto_increment_offset
|
||||
|
||||
@return auto_increment_offset
|
||||
*/
|
||||
ulong get_auto_increment_offset();
|
||||
|
||||
|
||||
/**
|
||||
Set server auto_increment_increment
|
||||
|
||||
@param[in] auto_increment_increment
|
||||
*/
|
||||
void set_auto_increment_increment(ulong auto_increment_increment);
|
||||
|
||||
|
||||
/**
|
||||
Set server auto_increment_offset
|
||||
|
||||
@param[in] auto_increment_offset
|
||||
*/
|
||||
void set_auto_increment_offset(ulong auto_increment_offset);
|
||||
|
||||
|
||||
/**
|
||||
Returns a struct containing all server startup information needed to evaluate
|
||||
if one has conditions to proceed executing master-master replication.
|
||||
|
||||
@param[out] requirements
|
||||
|
||||
@param[in] has_lock Caller should set this to true if the calling
|
||||
thread holds gtid_mode_lock; otherwise set it to false.
|
||||
*/
|
||||
void get_server_startup_prerequirements(Trans_context_info& requirements,
|
||||
bool has_lock);
|
||||
|
||||
|
||||
/**
|
||||
Returns the server GTID_EXECUTED encoded as a binary string.
|
||||
|
||||
@note Memory allocated to encoded_gtid_executed must be release by caller.
|
||||
|
||||
@param[out] encoded_gtid_executed binary string
|
||||
@param[out] length binary string length
|
||||
*/
|
||||
bool get_server_encoded_gtid_executed(uchar **encoded_gtid_executed,
|
||||
size_t *length);
|
||||
|
||||
#if !defined(NDEBUG)
|
||||
/**
|
||||
Returns a text representation of a encoded GTID set.
|
||||
|
||||
@note Memory allocated to returned pointer must be release by caller.
|
||||
|
||||
@param[in] encoded_gtid_set binary string
|
||||
@param[in] length binary string length
|
||||
|
||||
@return a pointer to text representation of the encoded set
|
||||
*/
|
||||
char* encoded_gtid_set_to_string(uchar *encoded_gtid_set, size_t length);
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
Return last gno for a given sidno, see
|
||||
Gtid_state::get_last_executed_gno() for details.
|
||||
*/
|
||||
rpl_gno get_last_executed_gno(rpl_sidno sidno);
|
||||
|
||||
|
||||
/**
|
||||
Return sidno for a given sid, see Sid_map::add_sid() for details.
|
||||
*/
|
||||
rpl_sidno get_sidno_from_global_sid_map(rpl_sid sid);
|
||||
|
||||
|
||||
/**
|
||||
Set slave thread default options.
|
||||
|
||||
@param[in] thd The thread
|
||||
*/
|
||||
void set_slave_thread_options(THD* thd);
|
||||
|
||||
|
||||
/**
|
||||
Add thread to Global_THD_manager singleton.
|
||||
|
||||
@param[in] thd The thread
|
||||
*/
|
||||
void global_thd_manager_add_thd(THD *thd);
|
||||
|
||||
|
||||
/**
|
||||
Remove thread from Global_THD_manager singleton.
|
||||
|
||||
@param[in] thd The thread
|
||||
*/
|
||||
void global_thd_manager_remove_thd(THD *thd);
|
||||
|
||||
/**
|
||||
Function that returns the write set extraction algorithm name.
|
||||
|
||||
@param[in] algorithm The algorithm value
|
||||
|
||||
@return the algorithm name
|
||||
*/
|
||||
const char* get_write_set_algorithm_string(unsigned int algorithm);
|
||||
|
||||
/**
|
||||
Returns the value of slave_max_allowed_packet.
|
||||
|
||||
@return slave_max_allowed_packet
|
||||
*/
|
||||
unsigned long get_slave_max_allowed_packet();
|
||||
|
||||
#endif /* GROUP_REPLICATION_PRIV_INCLUDE */
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
|
||||
|
||||
#ifndef INNODB_PRIV_INCLUDED
|
||||
#define INNODB_PRIV_INCLUDED
|
||||
|
||||
/** @file Declaring server-internal functions that are used by InnoDB. */
|
||||
|
||||
class THD;
|
||||
|
||||
int get_quote_char_for_identifier(THD *thd, const char *name, size_t length);
|
||||
bool schema_table_store_record(THD *thd, TABLE *table);
|
||||
void localtime_to_TIME(MYSQL_TIME *to, struct tm *from);
|
||||
bool check_global_access(THD *thd, ulong want_access);
|
||||
size_t strconvert(CHARSET_INFO *from_cs, const char *from,
|
||||
CHARSET_INFO *to_cs, char *to, size_t to_length,
|
||||
uint *errors);
|
||||
void sql_print_error(const char *format, ...);
|
||||
|
||||
/**
|
||||
Store record to I_S table, convert HEAP table to InnoDB table if necessary.
|
||||
|
||||
@param[in] thd thread handler
|
||||
@param[in] table Information schema table to be updated
|
||||
@param[in] make_ondisk if true, convert heap table to on disk table.
|
||||
default value is true.
|
||||
@return 0 on success
|
||||
@return error code on failure.
|
||||
*/
|
||||
int schema_table_store_record2(THD *thd, TABLE *table, bool make_ondisk);
|
||||
|
||||
/**
|
||||
Convert HEAP table to InnoDB table if necessary
|
||||
|
||||
@param[in] thd thread handler
|
||||
@param[in] table Information schema table to be converted.
|
||||
@param[in] error the error code returned previously.
|
||||
@return false on success, true on error.
|
||||
*/
|
||||
bool convert_heap_table_to_ondisk(THD *thd, TABLE *table, int error);
|
||||
|
||||
|
||||
#endif /* INNODB_PRIV_INCLUDED */
|
|
@ -0,0 +1,40 @@
|
|||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_LEX_STRING_INCLUDED
|
||||
#define MYSQL_LEX_STRING_INCLUDED
|
||||
|
||||
struct st_mysql_lex_string
|
||||
{
|
||||
char *str;
|
||||
size_t length;
|
||||
};
|
||||
typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
|
||||
|
||||
struct st_mysql_const_lex_string
|
||||
{
|
||||
const char *str;
|
||||
size_t length;
|
||||
};
|
||||
typedef struct st_mysql_const_lex_string MYSQL_LEX_CSTRING;
|
||||
|
||||
#endif // MYSQL_LEX_STRING_INCLUDED
|
|
@ -0,0 +1,752 @@
|
|||
/* Copyright (c) 2005, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef _my_plugin_h
|
||||
#define _my_plugin_h
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stddef.h>
|
||||
#include "mysql_version.h" /* MYSQL_VERSION_ID */
|
||||
#endif
|
||||
|
||||
/*
|
||||
On Windows, exports from DLL need to be declared.
|
||||
Also, plugin needs to be declared as extern "C" because MSVC
|
||||
unlike other compilers, uses C++ mangling for variables not only
|
||||
for functions.
|
||||
*/
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(MYSQL_DYNAMIC_PLUGIN)
|
||||
#ifdef __cplusplus
|
||||
#define MYSQL_PLUGIN_EXPORT extern "C" __declspec(dllexport)
|
||||
#else
|
||||
#define MYSQL_PLUGIN_EXPORT __declspec(dllexport)
|
||||
#endif
|
||||
#else /* MYSQL_DYNAMIC_PLUGIN */
|
||||
#ifdef __cplusplus
|
||||
#define MYSQL_PLUGIN_EXPORT extern "C"
|
||||
#else
|
||||
#define MYSQL_PLUGIN_EXPORT
|
||||
#endif
|
||||
#endif /*MYSQL_DYNAMIC_PLUGIN */
|
||||
#else /*_MSC_VER */
|
||||
#define MYSQL_PLUGIN_EXPORT
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
class THD;
|
||||
class Item;
|
||||
#define MYSQL_THD THD*
|
||||
#else
|
||||
#define MYSQL_THD void*
|
||||
#endif
|
||||
|
||||
typedef void * MYSQL_PLUGIN;
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <mysql/services.h>
|
||||
#endif
|
||||
|
||||
#define MYSQL_XIDDATASIZE 128
|
||||
/**
|
||||
struct st_mysql_xid is binary compatible with the XID structure as
|
||||
in the X/Open CAE Specification, Distributed Transaction Processing:
|
||||
The XA Specification, X/Open Company Ltd., 1991.
|
||||
http://www.opengroup.org/bookstore/catalog/c193.htm
|
||||
|
||||
@see XID in sql/handler.h
|
||||
*/
|
||||
struct st_mysql_xid {
|
||||
long formatID;
|
||||
long gtrid_length;
|
||||
long bqual_length;
|
||||
char data[MYSQL_XIDDATASIZE]; /* Not \0-terminated */
|
||||
};
|
||||
typedef struct st_mysql_xid MYSQL_XID;
|
||||
|
||||
/*************************************************************************
|
||||
Plugin API. Common for all plugin types.
|
||||
*/
|
||||
|
||||
#define MYSQL_PLUGIN_INTERFACE_VERSION 0x0107
|
||||
|
||||
/*
|
||||
The allowable types of plugins
|
||||
*/
|
||||
#define MYSQL_UDF_PLUGIN 0 /* User-defined function */
|
||||
#define MYSQL_STORAGE_ENGINE_PLUGIN 1 /* Storage Engine */
|
||||
#define MYSQL_FTPARSER_PLUGIN 2 /* Full-text parser plugin */
|
||||
#define MYSQL_DAEMON_PLUGIN 3 /* The daemon/raw plugin type */
|
||||
#define MYSQL_INFORMATION_SCHEMA_PLUGIN 4 /* The I_S plugin type */
|
||||
#define MYSQL_AUDIT_PLUGIN 5 /* The Audit plugin type */
|
||||
#define MYSQL_REPLICATION_PLUGIN 6 /* The replication plugin type */
|
||||
#define MYSQL_AUTHENTICATION_PLUGIN 7 /* The authentication plugin type */
|
||||
#define MYSQL_VALIDATE_PASSWORD_PLUGIN 8 /* validate password plugin type */
|
||||
#define MYSQL_GROUP_REPLICATION_PLUGIN 9 /* The Group Replication plugin */
|
||||
#define MYSQL_KEYRING_PLUGIN 10 /* The Keyring plugin type */
|
||||
#define MYSQL_MAX_PLUGIN_TYPE_NUM 11 /* The number of plugin types */
|
||||
|
||||
/* We use the following strings to define licenses for plugins */
|
||||
#define PLUGIN_LICENSE_PROPRIETARY 0
|
||||
#define PLUGIN_LICENSE_GPL 1
|
||||
#define PLUGIN_LICENSE_BSD 2
|
||||
|
||||
#define PLUGIN_LICENSE_PROPRIETARY_STRING "PROPRIETARY"
|
||||
#define PLUGIN_LICENSE_GPL_STRING "GPL"
|
||||
#define PLUGIN_LICENSE_BSD_STRING "BSD"
|
||||
|
||||
/*
|
||||
Macros for beginning and ending plugin declarations. Between
|
||||
mysql_declare_plugin and mysql_declare_plugin_end there should
|
||||
be a st_mysql_plugin struct for each plugin to be declared.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef MYSQL_DYNAMIC_PLUGIN
|
||||
#define __MYSQL_DECLARE_PLUGIN(NAME, VERSION, PSIZE, DECLS) \
|
||||
MYSQL_PLUGIN_EXPORT int VERSION= MYSQL_PLUGIN_INTERFACE_VERSION; \
|
||||
MYSQL_PLUGIN_EXPORT int PSIZE= sizeof(struct st_mysql_plugin); \
|
||||
MYSQL_PLUGIN_EXPORT struct st_mysql_plugin DECLS[]= {
|
||||
#else
|
||||
#define __MYSQL_DECLARE_PLUGIN(NAME, VERSION, PSIZE, DECLS) \
|
||||
MYSQL_PLUGIN_EXPORT int _mysql_plugin_interface_version_= MYSQL_PLUGIN_INTERFACE_VERSION; \
|
||||
MYSQL_PLUGIN_EXPORT int _mysql_sizeof_struct_st_plugin_= sizeof(struct st_mysql_plugin); \
|
||||
MYSQL_PLUGIN_EXPORT struct st_mysql_plugin _mysql_plugin_declarations_[]= {
|
||||
#endif
|
||||
|
||||
#define mysql_declare_plugin(NAME) \
|
||||
__MYSQL_DECLARE_PLUGIN(NAME, \
|
||||
builtin_ ## NAME ## _plugin_interface_version, \
|
||||
builtin_ ## NAME ## _sizeof_struct_st_plugin, \
|
||||
builtin_ ## NAME ## _plugin)
|
||||
|
||||
#define mysql_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0,0,0}}
|
||||
|
||||
/**
|
||||
Declarations for SHOW STATUS support in plugins
|
||||
*/
|
||||
enum enum_mysql_show_type
|
||||
{
|
||||
SHOW_UNDEF, SHOW_BOOL,
|
||||
SHOW_INT, ///< shown as _unsigned_ int
|
||||
SHOW_LONG, ///< shown as _unsigned_ long
|
||||
SHOW_LONGLONG, ///< shown as _unsigned_ longlong
|
||||
SHOW_CHAR, SHOW_CHAR_PTR,
|
||||
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
|
||||
#ifdef MYSQL_SERVER
|
||||
/*
|
||||
This include defines server-only values of the enum.
|
||||
Using them in plugins is not supported.
|
||||
*/
|
||||
#include "sql_plugin_enum.h"
|
||||
#endif
|
||||
};
|
||||
|
||||
/**
|
||||
Status variable scope.
|
||||
Only GLOBAL status variable scope is available in plugins.
|
||||
*/
|
||||
enum enum_mysql_show_scope
|
||||
{
|
||||
SHOW_SCOPE_UNDEF,
|
||||
SHOW_SCOPE_GLOBAL
|
||||
#ifdef MYSQL_SERVER
|
||||
/* Server-only values. Not supported in plugins. */
|
||||
,
|
||||
SHOW_SCOPE_SESSION,
|
||||
SHOW_SCOPE_ALL
|
||||
#endif
|
||||
};
|
||||
|
||||
/**
|
||||
SHOW STATUS Server status variable
|
||||
*/
|
||||
struct st_mysql_show_var
|
||||
{
|
||||
const char *name;
|
||||
char *value;
|
||||
enum enum_mysql_show_type type;
|
||||
enum enum_mysql_show_scope scope;
|
||||
};
|
||||
|
||||
#define SHOW_VAR_MAX_NAME_LEN 64
|
||||
#define SHOW_VAR_FUNC_BUFF_SIZE 1024
|
||||
typedef int (*mysql_show_var_func)(MYSQL_THD, struct st_mysql_show_var*, char *);
|
||||
|
||||
|
||||
/*
|
||||
Constants for plugin flags.
|
||||
*/
|
||||
|
||||
#define PLUGIN_OPT_NO_INSTALL 1UL /* Not dynamically loadable */
|
||||
#define PLUGIN_OPT_NO_UNINSTALL 2UL /* Not dynamically unloadable */
|
||||
|
||||
|
||||
/*
|
||||
declarations for server variables and command line options
|
||||
*/
|
||||
|
||||
|
||||
#define PLUGIN_VAR_BOOL 0x0001
|
||||
#define PLUGIN_VAR_INT 0x0002
|
||||
#define PLUGIN_VAR_LONG 0x0003
|
||||
#define PLUGIN_VAR_LONGLONG 0x0004
|
||||
#define PLUGIN_VAR_STR 0x0005
|
||||
#define PLUGIN_VAR_ENUM 0x0006
|
||||
#define PLUGIN_VAR_SET 0x0007
|
||||
#define PLUGIN_VAR_DOUBLE 0x0008
|
||||
#define PLUGIN_VAR_UNSIGNED 0x0080
|
||||
#define PLUGIN_VAR_THDLOCAL 0x0100 /* Variable is per-connection */
|
||||
#define PLUGIN_VAR_READONLY 0x0200 /* Server variable is read only */
|
||||
#define PLUGIN_VAR_NOSYSVAR 0x0400 /* Not a server variable */
|
||||
#define PLUGIN_VAR_NOCMDOPT 0x0800 /* Not a command line option */
|
||||
#define PLUGIN_VAR_NOCMDARG 0x1000 /* No argument for cmd line */
|
||||
#define PLUGIN_VAR_RQCMDARG 0x0000 /* Argument required for cmd line */
|
||||
#define PLUGIN_VAR_OPCMDARG 0x2000 /* Argument optional for cmd line */
|
||||
#define PLUGIN_VAR_NODEFAULT 0x4000 /* SET DEFAULT is prohibited */
|
||||
#define PLUGIN_VAR_MEMALLOC 0x8000 /* String needs memory allocated */
|
||||
#define PLUGIN_VAR_INVISIBLE 0x10000 /* Variable should not be shown */
|
||||
|
||||
struct st_mysql_sys_var;
|
||||
struct st_mysql_value;
|
||||
|
||||
/*
|
||||
SYNOPSIS
|
||||
(*mysql_var_check_func)()
|
||||
thd thread handle
|
||||
var dynamic variable being altered
|
||||
save pointer to temporary storage
|
||||
value user provided value
|
||||
RETURN
|
||||
0 user provided value is OK and the update func may be called.
|
||||
any other value indicates error.
|
||||
|
||||
This function should parse the user provided value and store in the
|
||||
provided temporary storage any data as required by the update func.
|
||||
There is sufficient space in the temporary storage to store a double.
|
||||
Note that the update func may not be called if any other error occurs
|
||||
so any memory allocated should be thread-local so that it may be freed
|
||||
automatically at the end of the statement.
|
||||
*/
|
||||
|
||||
typedef int (*mysql_var_check_func)(MYSQL_THD thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *save, struct st_mysql_value *value);
|
||||
|
||||
/*
|
||||
SYNOPSIS
|
||||
(*mysql_var_update_func)()
|
||||
thd thread handle
|
||||
var dynamic variable being altered
|
||||
var_ptr pointer to dynamic variable
|
||||
save pointer to temporary storage
|
||||
RETURN
|
||||
NONE
|
||||
|
||||
This function should use the validated value stored in the temporary store
|
||||
and persist it in the provided pointer to the dynamic variable.
|
||||
For example, strings may require memory to be allocated.
|
||||
*/
|
||||
typedef void (*mysql_var_update_func)(MYSQL_THD thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *var_ptr, const void *save);
|
||||
|
||||
|
||||
/* the following declarations are for internal use only */
|
||||
|
||||
|
||||
#define PLUGIN_VAR_MASK \
|
||||
(PLUGIN_VAR_READONLY | PLUGIN_VAR_NOSYSVAR | \
|
||||
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_NOCMDARG | \
|
||||
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC | \
|
||||
PLUGIN_VAR_NODEFAULT | PLUGIN_VAR_INVISIBLE)
|
||||
|
||||
#define MYSQL_PLUGIN_VAR_HEADER \
|
||||
int flags; \
|
||||
const char *name; \
|
||||
const char *comment; \
|
||||
mysql_var_check_func check; \
|
||||
mysql_var_update_func update
|
||||
|
||||
#define MYSQL_SYSVAR_NAME(name) mysql_sysvar_ ## name
|
||||
#define MYSQL_SYSVAR(name) \
|
||||
((struct st_mysql_sys_var *)&(MYSQL_SYSVAR_NAME(name)))
|
||||
|
||||
/*
|
||||
for global variables, the value pointer is the first
|
||||
element after the header, the default value is the second.
|
||||
for thread variables, the value offset is the first
|
||||
element after the header, the default value is the second.
|
||||
*/
|
||||
|
||||
|
||||
#define DECLARE_MYSQL_SYSVAR_BASIC(name, type) struct { \
|
||||
MYSQL_PLUGIN_VAR_HEADER; \
|
||||
type *value; \
|
||||
const type def_val; \
|
||||
} MYSQL_SYSVAR_NAME(name)
|
||||
|
||||
#define DECLARE_MYSQL_SYSVAR_SIMPLE(name, type) struct { \
|
||||
MYSQL_PLUGIN_VAR_HEADER; \
|
||||
type *value; type def_val; \
|
||||
type min_val; type max_val; \
|
||||
type blk_sz; \
|
||||
} MYSQL_SYSVAR_NAME(name)
|
||||
|
||||
#define DECLARE_MYSQL_SYSVAR_TYPELIB(name, type) struct { \
|
||||
MYSQL_PLUGIN_VAR_HEADER; \
|
||||
type *value; type def_val; \
|
||||
TYPELIB *typelib; \
|
||||
} MYSQL_SYSVAR_NAME(name)
|
||||
|
||||
#define DECLARE_THDVAR_FUNC(type) \
|
||||
type *(*resolve)(MYSQL_THD thd, int offset)
|
||||
|
||||
#define DECLARE_MYSQL_THDVAR_BASIC(name, type) struct { \
|
||||
MYSQL_PLUGIN_VAR_HEADER; \
|
||||
int offset; \
|
||||
const type def_val; \
|
||||
DECLARE_THDVAR_FUNC(type); \
|
||||
} MYSQL_SYSVAR_NAME(name)
|
||||
|
||||
#define DECLARE_MYSQL_THDVAR_SIMPLE(name, type) struct { \
|
||||
MYSQL_PLUGIN_VAR_HEADER; \
|
||||
int offset; \
|
||||
type def_val; type min_val; \
|
||||
type max_val; type blk_sz; \
|
||||
DECLARE_THDVAR_FUNC(type); \
|
||||
} MYSQL_SYSVAR_NAME(name)
|
||||
|
||||
#define DECLARE_MYSQL_THDVAR_TYPELIB(name, type) struct { \
|
||||
MYSQL_PLUGIN_VAR_HEADER; \
|
||||
int offset; \
|
||||
type def_val; \
|
||||
DECLARE_THDVAR_FUNC(type); \
|
||||
TYPELIB *typelib; \
|
||||
} MYSQL_SYSVAR_NAME(name)
|
||||
|
||||
|
||||
/*
|
||||
the following declarations are for use by plugin implementors
|
||||
*/
|
||||
|
||||
#define MYSQL_SYSVAR_BOOL(name, varname, opt, comment, check, update, def) \
|
||||
DECLARE_MYSQL_SYSVAR_BASIC(name, char) = { \
|
||||
PLUGIN_VAR_BOOL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def}
|
||||
|
||||
#define MYSQL_SYSVAR_STR(name, varname, opt, comment, check, update, def) \
|
||||
DECLARE_MYSQL_SYSVAR_BASIC(name, char *) = { \
|
||||
PLUGIN_VAR_STR | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def}
|
||||
|
||||
#define MYSQL_SYSVAR_INT(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, int) = { \
|
||||
PLUGIN_VAR_INT | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_SYSVAR_UINT(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned int) = { \
|
||||
PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_SYSVAR_LONG(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, long) = { \
|
||||
PLUGIN_VAR_LONG | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_SYSVAR_ULONG(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned long) = { \
|
||||
PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_SYSVAR_LONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, long long) = { \
|
||||
PLUGIN_VAR_LONGLONG | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_SYSVAR_ULONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned long long) = { \
|
||||
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_SYSVAR_ENUM(name, varname, opt, comment, check, update, def, typelib) \
|
||||
DECLARE_MYSQL_SYSVAR_TYPELIB(name, unsigned long) = { \
|
||||
PLUGIN_VAR_ENUM | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, typelib }
|
||||
|
||||
#define MYSQL_SYSVAR_SET(name, varname, opt, comment, check, update, def, typelib) \
|
||||
DECLARE_MYSQL_SYSVAR_TYPELIB(name, unsigned long long) = { \
|
||||
PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, typelib }
|
||||
|
||||
#define MYSQL_SYSVAR_DOUBLE(name, varname, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_SYSVAR_SIMPLE(name, double) = { \
|
||||
PLUGIN_VAR_DOUBLE | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, &varname, def, min, max, blk }
|
||||
|
||||
#define MYSQL_THDVAR_BOOL(name, opt, comment, check, update, def) \
|
||||
DECLARE_MYSQL_THDVAR_BASIC(name, char) = { \
|
||||
PLUGIN_VAR_BOOL | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, NULL}
|
||||
|
||||
#define MYSQL_THDVAR_STR(name, opt, comment, check, update, def) \
|
||||
DECLARE_MYSQL_THDVAR_BASIC(name, char *) = { \
|
||||
PLUGIN_VAR_STR | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, NULL}
|
||||
|
||||
#define MYSQL_THDVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, int) = { \
|
||||
PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
#define MYSQL_THDVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned int) = { \
|
||||
PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
#define MYSQL_THDVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, long) = { \
|
||||
PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
#define MYSQL_THDVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned long) = { \
|
||||
PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
#define MYSQL_THDVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, long long) = { \
|
||||
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
#define MYSQL_THDVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned long long) = { \
|
||||
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
#define MYSQL_THDVAR_ENUM(name, opt, comment, check, update, def, typelib) \
|
||||
DECLARE_MYSQL_THDVAR_TYPELIB(name, unsigned long) = { \
|
||||
PLUGIN_VAR_ENUM | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, NULL, typelib }
|
||||
|
||||
#define MYSQL_THDVAR_SET(name, opt, comment, check, update, def, typelib) \
|
||||
DECLARE_MYSQL_THDVAR_TYPELIB(name, unsigned long long) = { \
|
||||
PLUGIN_VAR_SET | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, NULL, typelib }
|
||||
|
||||
#define MYSQL_THDVAR_DOUBLE(name, opt, comment, check, update, def, min, max, blk) \
|
||||
DECLARE_MYSQL_THDVAR_SIMPLE(name, double) = { \
|
||||
PLUGIN_VAR_DOUBLE | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
|
||||
#name, comment, check, update, -1, def, min, max, blk, NULL }
|
||||
|
||||
/* accessor macros */
|
||||
|
||||
#define SYSVAR(name) \
|
||||
(*(MYSQL_SYSVAR_NAME(name).value))
|
||||
|
||||
/* when thd == null, result points to global value */
|
||||
#define THDVAR(thd, name) \
|
||||
(*(MYSQL_SYSVAR_NAME(name).resolve(thd, MYSQL_SYSVAR_NAME(name).offset)))
|
||||
|
||||
|
||||
/*
|
||||
Plugin description structure.
|
||||
*/
|
||||
|
||||
struct st_mysql_plugin
|
||||
{
|
||||
int type; /* the plugin type (a MYSQL_XXX_PLUGIN value) */
|
||||
void *info; /* pointer to type-specific plugin descriptor */
|
||||
const char *name; /* plugin name */
|
||||
const char *author; /* plugin author (for I_S.PLUGINS) */
|
||||
const char *descr; /* general descriptive text (for I_S.PLUGINS) */
|
||||
int license; /* the plugin license (PLUGIN_LICENSE_XXX) */
|
||||
int (*init)(MYSQL_PLUGIN); /* the function to invoke when plugin is loaded */
|
||||
int (*deinit)(MYSQL_PLUGIN);/* the function to invoke when plugin is unloaded */
|
||||
unsigned int version; /* plugin version (for I_S.PLUGINS) */
|
||||
struct st_mysql_show_var *status_vars;
|
||||
struct st_mysql_sys_var **system_vars;
|
||||
void * __reserved1; /* reserved for dependency checking */
|
||||
unsigned long flags; /* flags for plugin */
|
||||
};
|
||||
|
||||
/*************************************************************************
|
||||
API for Full-text parser plugin. (MYSQL_FTPARSER_PLUGIN)
|
||||
*/
|
||||
#define MYSQL_FTPARSER_INTERFACE_VERSION 0x0101
|
||||
|
||||
/*************************************************************************
|
||||
API for Query Rewrite plugin. (MYSQL_QUERY_REWRITE_PLUGIN)
|
||||
*/
|
||||
|
||||
#define MYSQL_REWRITE_PRE_PARSE_INTERFACE_VERSION 0x0010
|
||||
#define MYSQL_REWRITE_POST_PARSE_INTERFACE_VERSION 0x0010
|
||||
|
||||
/*************************************************************************
|
||||
API for Storage Engine plugin. (MYSQL_DAEMON_PLUGIN)
|
||||
*/
|
||||
|
||||
/* handlertons of different MySQL releases are incompatible */
|
||||
#define MYSQL_DAEMON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
|
||||
|
||||
/*
|
||||
Here we define only the descriptor structure, that is referred from
|
||||
st_mysql_plugin.
|
||||
*/
|
||||
|
||||
struct st_mysql_daemon
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
API for I_S plugin. (MYSQL_INFORMATION_SCHEMA_PLUGIN)
|
||||
*/
|
||||
|
||||
/* handlertons of different MySQL releases are incompatible */
|
||||
#define MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
|
||||
|
||||
/*
|
||||
Here we define only the descriptor structure, that is referred from
|
||||
st_mysql_plugin.
|
||||
*/
|
||||
|
||||
struct st_mysql_information_schema
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
API for Storage Engine plugin. (MYSQL_STORAGE_ENGINE_PLUGIN)
|
||||
*/
|
||||
|
||||
/* handlertons of different MySQL releases are incompatible */
|
||||
#define MYSQL_HANDLERTON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
|
||||
|
||||
/*
|
||||
The real API is in the sql/handler.h
|
||||
Here we define only the descriptor structure, that is referred from
|
||||
st_mysql_plugin.
|
||||
*/
|
||||
|
||||
struct st_mysql_storage_engine
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
|
||||
struct handlerton;
|
||||
|
||||
|
||||
/*
|
||||
API for Replication plugin. (MYSQL_REPLICATION_PLUGIN)
|
||||
*/
|
||||
#define MYSQL_REPLICATION_INTERFACE_VERSION 0x0400
|
||||
|
||||
/**
|
||||
Replication plugin descriptor
|
||||
*/
|
||||
struct Mysql_replication {
|
||||
int interface_version;
|
||||
};
|
||||
|
||||
/*************************************************************************
|
||||
st_mysql_value struct for reading values from mysqld.
|
||||
Used by server variables framework to parse user-provided values.
|
||||
Will be used for arguments when implementing UDFs.
|
||||
|
||||
Note that val_str() returns a string in temporary memory
|
||||
that will be freed at the end of statement. Copy the string
|
||||
if you need it to persist.
|
||||
*/
|
||||
|
||||
#define MYSQL_VALUE_TYPE_STRING 0
|
||||
#define MYSQL_VALUE_TYPE_REAL 1
|
||||
#define MYSQL_VALUE_TYPE_INT 2
|
||||
|
||||
struct st_mysql_value
|
||||
{
|
||||
int (*value_type)(struct st_mysql_value *);
|
||||
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
|
||||
int (*val_real)(struct st_mysql_value *, double *realbuf);
|
||||
int (*val_int)(struct st_mysql_value *, long long *intbuf);
|
||||
int (*is_unsigned)(struct st_mysql_value *);
|
||||
};
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
Miscellaneous functions for plugin implementors
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int thd_in_lock_tables(const MYSQL_THD thd);
|
||||
int thd_tablespace_op(const MYSQL_THD thd);
|
||||
long long thd_test_options(const MYSQL_THD thd, long long test_options);
|
||||
int thd_sql_command(const MYSQL_THD thd);
|
||||
const char *set_thd_proc_info(MYSQL_THD thd, const char *info,
|
||||
const char *calling_func,
|
||||
const char *calling_file,
|
||||
const unsigned int calling_line);
|
||||
void **thd_ha_data(const MYSQL_THD thd, const struct handlerton *hton);
|
||||
void thd_storage_lock_wait(MYSQL_THD thd, long long value);
|
||||
int thd_tx_isolation(const MYSQL_THD thd);
|
||||
int thd_tx_is_read_only(const MYSQL_THD thd);
|
||||
MYSQL_THD thd_tx_arbitrate(MYSQL_THD requestor, MYSQL_THD holder);
|
||||
int thd_tx_priority(const MYSQL_THD thd);
|
||||
int thd_tx_is_dd_trx(const MYSQL_THD thd);
|
||||
char *thd_security_context(MYSQL_THD thd, char *buffer, size_t length,
|
||||
size_t max_query_len);
|
||||
/* Increments the row counter, see THD::row_count */
|
||||
void thd_inc_row_count(MYSQL_THD thd);
|
||||
int thd_allow_batch(MYSQL_THD thd);
|
||||
|
||||
|
||||
/**
|
||||
Mark transaction to rollback and mark error as fatal to a
|
||||
sub-statement if in sub statement mode.
|
||||
|
||||
@param thd user thread connection handle
|
||||
@param all if all != 0, rollback the main transaction
|
||||
*/
|
||||
|
||||
void thd_mark_transaction_to_rollback(MYSQL_THD thd, int all);
|
||||
|
||||
/**
|
||||
Create a temporary file.
|
||||
|
||||
@details
|
||||
The temporary file is created in a location specified by the mysql
|
||||
server configuration (--tmpdir option). The caller does not need to
|
||||
delete the file, it will be deleted automatically.
|
||||
|
||||
@param prefix prefix for temporary file name
|
||||
@retval -1 error
|
||||
@retval >= 0 a file handle that can be passed to dup or my_close
|
||||
*/
|
||||
int mysql_tmpfile(const char *prefix);
|
||||
|
||||
/**
|
||||
Check the killed state of a connection
|
||||
|
||||
@details
|
||||
In MySQL support for the KILL statement is cooperative. The KILL
|
||||
statement only sets a "killed" flag. This function returns the value
|
||||
of that flag. A thread should check it often, especially inside
|
||||
time-consuming loops, and gracefully abort the operation if it is
|
||||
non-zero.
|
||||
|
||||
@param thd user thread connection handle
|
||||
@retval 0 the connection is active
|
||||
@retval 1 the connection has been killed
|
||||
*/
|
||||
int thd_killed(const MYSQL_THD thd);
|
||||
|
||||
/**
|
||||
Set the killed status of the current statement.
|
||||
|
||||
@param thd user thread connection handle
|
||||
*/
|
||||
void thd_set_kill_status(const MYSQL_THD thd);
|
||||
|
||||
/**
|
||||
Get binary log position for latest written entry.
|
||||
|
||||
@note The file variable will be set to a buffer holding the name of
|
||||
the file name currently, but this can change if a rotation
|
||||
occur. Copy the string if you want to retain it.
|
||||
|
||||
@param thd Use thread connection handle
|
||||
@param file_var Pointer to variable that will hold the file name.
|
||||
@param pos_var Pointer to variable that will hold the file position.
|
||||
*/
|
||||
void thd_binlog_pos(const MYSQL_THD thd,
|
||||
const char **file_var,
|
||||
unsigned long long *pos_var);
|
||||
|
||||
/**
|
||||
Return the thread id of a user thread
|
||||
|
||||
@param thd user thread connection handle
|
||||
@return thread id
|
||||
*/
|
||||
unsigned long thd_get_thread_id(const MYSQL_THD thd);
|
||||
|
||||
/**
|
||||
Get the XID for this connection's transaction
|
||||
|
||||
@param thd user thread connection handle
|
||||
@param xid location where identifier is stored
|
||||
*/
|
||||
void thd_get_xid(const MYSQL_THD thd, MYSQL_XID *xid);
|
||||
|
||||
/**
|
||||
Invalidate the query cache for a given table.
|
||||
|
||||
@param thd user thread connection handle
|
||||
@param key databasename/tablename in the canonical format.
|
||||
@param key_length length of key in bytes, including the PATH separator
|
||||
@param using_trx flag: TRUE if using transactions, FALSE otherwise
|
||||
*/
|
||||
void mysql_query_cache_invalidate4(MYSQL_THD thd,
|
||||
const char *key, unsigned int key_length,
|
||||
int using_trx);
|
||||
|
||||
|
||||
/**
|
||||
Provide a handler data getter to simplify coding
|
||||
*/
|
||||
void *thd_get_ha_data(const MYSQL_THD thd, const struct handlerton *hton);
|
||||
|
||||
|
||||
/**
|
||||
Provide a handler data setter to simplify coding
|
||||
|
||||
@details
|
||||
Set ha_data pointer (storage engine per-connection information).
|
||||
|
||||
To avoid unclean deactivation (uninstall) of storage engine plugin
|
||||
in the middle of transaction, additional storage engine plugin
|
||||
lock is acquired.
|
||||
|
||||
If ha_data is not null and storage engine plugin was not locked
|
||||
by thd_set_ha_data() in this connection before, storage engine
|
||||
plugin gets locked.
|
||||
|
||||
If ha_data is null and storage engine plugin was locked by
|
||||
thd_set_ha_data() in this connection before, storage engine
|
||||
plugin lock gets released.
|
||||
|
||||
If handlerton::close_connection() didn't reset ha_data, server does
|
||||
it immediately after calling handlerton::close_connection().
|
||||
*/
|
||||
void thd_set_ha_data(MYSQL_THD thd, const struct handlerton *hton,
|
||||
const void *ha_data);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _my_plugin_h */
|
|
@ -0,0 +1,565 @@
|
|||
/* Copyright (c) 2007, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef _my_audit_h
|
||||
#define _my_audit_h
|
||||
|
||||
#include "plugin.h"
|
||||
#include "mysql/mysql_lex_string.h"
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include "m_string.h"
|
||||
#endif
|
||||
#include "my_command.h"
|
||||
#include "my_sqlcommand.h"
|
||||
|
||||
#define MYSQL_AUDIT_INTERFACE_VERSION 0x0401
|
||||
|
||||
/**
|
||||
@enum mysql_event_class_t
|
||||
|
||||
Audit event classes.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_GENERAL_CLASS = 0,
|
||||
MYSQL_AUDIT_CONNECTION_CLASS = 1,
|
||||
MYSQL_AUDIT_PARSE_CLASS = 2,
|
||||
MYSQL_AUDIT_AUTHORIZATION_CLASS = 3,
|
||||
MYSQL_AUDIT_TABLE_ACCESS_CLASS = 4,
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_CLASS = 5,
|
||||
MYSQL_AUDIT_SERVER_STARTUP_CLASS = 6,
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_CLASS = 7,
|
||||
MYSQL_AUDIT_COMMAND_CLASS = 8,
|
||||
MYSQL_AUDIT_QUERY_CLASS = 9,
|
||||
MYSQL_AUDIT_STORED_PROGRAM_CLASS = 10,
|
||||
/* This item must be last in the list. */
|
||||
MYSQL_AUDIT_CLASS_MASK_SIZE
|
||||
} mysql_event_class_t;
|
||||
|
||||
/**
|
||||
@struct st_mysql_audit
|
||||
|
||||
The descriptor structure that is referred from st_mysql_plugin.
|
||||
*/
|
||||
struct st_mysql_audit
|
||||
{
|
||||
/**
|
||||
Interface version.
|
||||
*/
|
||||
int interface_version;
|
||||
|
||||
/**
|
||||
Event occurs when the event class consumer is to be
|
||||
disassociated from the specified THD.This would typically occur
|
||||
before some operation which may require sleeping - such as when
|
||||
waiting for the next query from the client.
|
||||
*/
|
||||
void (*release_thd)(MYSQL_THD);
|
||||
|
||||
/**
|
||||
Invoked whenever an event occurs which is of any
|
||||
class for which the plugin has interest.The second argument
|
||||
indicates the specific event class and the third argument is data
|
||||
as required for that class.
|
||||
*/
|
||||
int (*event_notify)(MYSQL_THD, mysql_event_class_t, const void *);
|
||||
|
||||
/**
|
||||
An array of bits used to indicate what event classes
|
||||
that this plugin wants to receive.
|
||||
*/
|
||||
unsigned long class_mask[MYSQL_AUDIT_CLASS_MASK_SIZE];
|
||||
};
|
||||
|
||||
/**
|
||||
@typedef enum_sql_command_t
|
||||
|
||||
SQL command type definition.
|
||||
*/
|
||||
typedef enum enum_sql_command enum_sql_command_t;
|
||||
|
||||
/**
|
||||
@enum mysql_event_general_subclass_t
|
||||
|
||||
Events for the MYSQL_AUDIT_GENERAL_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** occurs before emitting to the general query log. */
|
||||
MYSQL_AUDIT_GENERAL_LOG = 1 << 0,
|
||||
/** occurs before transmitting errors to the user. */
|
||||
MYSQL_AUDIT_GENERAL_ERROR = 1 << 1,
|
||||
/** occurs after transmitting a resultset to the user. */
|
||||
MYSQL_AUDIT_GENERAL_RESULT = 1 << 2,
|
||||
/** occurs after transmitting a resultset or errors */
|
||||
MYSQL_AUDIT_GENERAL_STATUS = 1 << 3
|
||||
} mysql_event_general_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_GENERAL_ALL (MYSQL_AUDIT_GENERAL_LOG | \
|
||||
MYSQL_AUDIT_GENERAL_ERROR | \
|
||||
MYSQL_AUDIT_GENERAL_RESULT | \
|
||||
MYSQL_AUDIT_GENERAL_STATUS)
|
||||
/**
|
||||
@struct mysql_event_general
|
||||
|
||||
Structure for the MYSQL_AUDIT_GENERAL_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_general
|
||||
{
|
||||
mysql_event_general_subclass_t event_subclass;
|
||||
int general_error_code;
|
||||
unsigned long general_thread_id;
|
||||
MYSQL_LEX_CSTRING general_user;
|
||||
MYSQL_LEX_CSTRING general_command;
|
||||
MYSQL_LEX_CSTRING general_query;
|
||||
struct charset_info_st *general_charset;
|
||||
unsigned long long general_time;
|
||||
unsigned long long general_rows;
|
||||
MYSQL_LEX_CSTRING general_host;
|
||||
MYSQL_LEX_CSTRING general_sql_command;
|
||||
MYSQL_LEX_CSTRING general_external_user;
|
||||
MYSQL_LEX_CSTRING general_ip;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_connection_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_CONNECTION_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** occurs after authentication phase is completed. */
|
||||
MYSQL_AUDIT_CONNECTION_CONNECT = 1 << 0,
|
||||
/** occurs after connection is terminated. */
|
||||
MYSQL_AUDIT_CONNECTION_DISCONNECT = 1 << 1,
|
||||
/** occurs after COM_CHANGE_USER RPC is completed. */
|
||||
MYSQL_AUDIT_CONNECTION_CHANGE_USER = 1 << 2,
|
||||
/** occurs before authentication. */
|
||||
MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE = 1 << 3
|
||||
} mysql_event_connection_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_CONNECTION_ALL (MYSQL_AUDIT_CONNECTION_CONNECT | \
|
||||
MYSQL_AUDIT_CONNECTION_DISCONNECT | \
|
||||
MYSQL_AUDIT_CONNECTION_CHANGE_USER | \
|
||||
MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE)
|
||||
/**
|
||||
@struct mysql_event_connection
|
||||
|
||||
Structure for the MYSQL_AUDIT_CONNECTION_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_connection
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_connection_subclass_t event_subclass;
|
||||
/** Current status of the connection. */
|
||||
int status;
|
||||
/** Connection id. */
|
||||
unsigned long connection_id;
|
||||
/** User name of this connection. */
|
||||
MYSQL_LEX_CSTRING user;
|
||||
/** Priv user name. */
|
||||
MYSQL_LEX_CSTRING priv_user;
|
||||
/** External user name. */
|
||||
MYSQL_LEX_CSTRING external_user;
|
||||
/** Proxy user used for this connection. */
|
||||
MYSQL_LEX_CSTRING proxy_user;
|
||||
/** Connection host. */
|
||||
MYSQL_LEX_CSTRING host;
|
||||
/** IP of the connection. */
|
||||
MYSQL_LEX_CSTRING ip;
|
||||
/** Database name specified at connection time. */
|
||||
MYSQL_LEX_CSTRING database;
|
||||
/** Connection type:
|
||||
- 0 Undefined
|
||||
- 1 TCP/IP
|
||||
- 2 Socket
|
||||
- 3 Named pipe
|
||||
- 4 SSL
|
||||
- 5 Shared memory
|
||||
*/
|
||||
int connection_type;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_parse_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_PARSE_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** occurs before the query parsing. */
|
||||
MYSQL_AUDIT_PARSE_PREPARSE = 1 << 0,
|
||||
/** occurs after the query parsing. */
|
||||
MYSQL_AUDIT_PARSE_POSTPARSE = 1 << 1
|
||||
} mysql_event_parse_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_PARSE_ALL (MYSQL_AUDIT_PARSE_PREPARSE | \
|
||||
MYSQL_AUDIT_PARSE_POSTPARSE)
|
||||
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_PARSE_REWRITE_PLUGIN_NONE = 0,
|
||||
/// mysql_event_parse::flags Must be set by a plugin if the query is rewritten.
|
||||
MYSQL_AUDIT_PARSE_REWRITE_PLUGIN_QUERY_REWRITTEN = 1 << 0,
|
||||
/// mysql_event_parse::flags Is set by the server if the query is prepared statement.
|
||||
MYSQL_AUDIT_PARSE_REWRITE_PLUGIN_IS_PREPARED_STATEMENT = 1 << 1
|
||||
} mysql_event_parse_rewrite_plugin_flag;
|
||||
|
||||
/** Data for the MYSQL_AUDIT_PARSE events */
|
||||
struct mysql_event_parse
|
||||
{
|
||||
/** MYSQL_AUDIT_[PRE|POST]_PARSE event id */
|
||||
mysql_event_parse_subclass_t event_subclass;
|
||||
|
||||
/** one of FLAG_REWRITE_PLUGIN_* */
|
||||
mysql_event_parse_rewrite_plugin_flag *flags;
|
||||
|
||||
/** input: the original query text */
|
||||
MYSQL_LEX_CSTRING query;
|
||||
|
||||
/** output: returns the null-terminated rewriten query allocated by my_malloc() */
|
||||
MYSQL_LEX_CSTRING *rewritten_query;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_authorization_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_AUTHORIZATION_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_AUTHORIZATION_USER = 1 << 0,
|
||||
/** Occurs when database privilege is checked. */
|
||||
MYSQL_AUDIT_AUTHORIZATION_DB = 1 << 1,
|
||||
/** Occurs when table privilege is checked. */
|
||||
MYSQL_AUDIT_AUTHORIZATION_TABLE = 1 << 2,
|
||||
/** Occurs when column privilege is checked. */
|
||||
MYSQL_AUDIT_AUTHORIZATION_COLUMN = 1 << 3,
|
||||
/** Occurs when procedure privilege is checked. */
|
||||
MYSQL_AUDIT_AUTHORIZATION_PROCEDURE = 1 << 4,
|
||||
/** Occurs when proxy privilege is checked. */
|
||||
MYSQL_AUDIT_AUTHORIZATION_PROXY = 1 << 5
|
||||
} mysql_event_authorization_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_AUTHORIZATION_ALL (MYSQL_AUDIT_AUTHORIZATION_USER | \
|
||||
MYSQL_AUDIT_AUTHORIZATION_DB | \
|
||||
MYSQL_AUDIT_AUTHORIZATION_TABLE | \
|
||||
MYSQL_AUDIT_AUTHORIZATION_COLUMN | \
|
||||
MYSQL_AUDIT_AUTHORIZATION_PROCEDURE | \
|
||||
MYSQL_AUDIT_AUTHORIZATION_PROXY)
|
||||
/**
|
||||
@struct mysql_event_authorization
|
||||
|
||||
Structure for MYSQL_AUDIT_AUTHORIZATION_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_authorization
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_authorization_subclass_t event_subclass;
|
||||
/** Event status. */
|
||||
int status;
|
||||
/** Connection id. */
|
||||
unsigned int connection_id;
|
||||
/** SQL command id. */
|
||||
enum_sql_command_t sql_command_id;
|
||||
/** SQL query text. */
|
||||
MYSQL_LEX_CSTRING query;
|
||||
/** SQL query charset. */
|
||||
const struct charset_info_st *query_charset;
|
||||
/** Database name. */
|
||||
MYSQL_LEX_CSTRING database;
|
||||
/** Table name. */
|
||||
MYSQL_LEX_CSTRING table;
|
||||
/** Other name associated with the event. */
|
||||
MYSQL_LEX_CSTRING object;
|
||||
/** Requested authorization privileges. */
|
||||
unsigned long requested_privilege;
|
||||
/** Currently granted authorization privileges. */
|
||||
unsigned long granted_privilege;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_table_row_access_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_TABLE_ACCES_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Occurs when table data are read. */
|
||||
MYSQL_AUDIT_TABLE_ACCESS_READ = 1 << 0,
|
||||
/** Occurs when table data are inserted. */
|
||||
MYSQL_AUDIT_TABLE_ACCESS_INSERT = 1 << 1,
|
||||
/** Occurs when table data are updated. */
|
||||
MYSQL_AUDIT_TABLE_ACCESS_UPDATE = 1 << 2,
|
||||
/** Occurs when table data are deleted. */
|
||||
MYSQL_AUDIT_TABLE_ACCESS_DELETE = 1 << 3
|
||||
} mysql_event_table_access_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_TABLE_ACCESS_ALL (MYSQL_AUDIT_TABLE_ACCESS_READ | \
|
||||
MYSQL_AUDIT_TABLE_ACCESS_INSERT | \
|
||||
MYSQL_AUDIT_TABLE_ACCESS_UPDATE | \
|
||||
MYSQL_AUDIT_TABLE_ACCESS_DELETE)
|
||||
|
||||
/**
|
||||
@struct mysql_event_table_row_access
|
||||
|
||||
Structure for MYSQL_AUDIT_TABLE_ACCES_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_table_access
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_table_access_subclass_t event_subclass;
|
||||
/** Connection id. */
|
||||
unsigned long connection_id;
|
||||
/** SQL command id. */
|
||||
enum_sql_command_t sql_command_id;
|
||||
/** SQL query. */
|
||||
MYSQL_LEX_CSTRING query;
|
||||
/** SQL query charset. */
|
||||
const struct charset_info_st *query_charset;
|
||||
/** Database name. */
|
||||
MYSQL_LEX_CSTRING table_database;
|
||||
/** Table name. */
|
||||
MYSQL_LEX_CSTRING table_name;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_global_variable_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_GLOBAL_VARIABLE_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Occurs when global variable is retrieved. */
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_GET = 1 << 0,
|
||||
/** Occurs when global variable is set. */
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_SET = 1 << 1
|
||||
} mysql_event_global_variable_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_GLOBAL_VARIABLE_ALL (MYSQL_AUDIT_GLOBAL_VARIABLE_GET | \
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_SET)
|
||||
|
||||
/** Events for MYSQL_AUDIT_GLOBAL_VARIABLE_CLASS event class. */
|
||||
struct mysql_event_global_variable
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_global_variable_subclass_t event_subclass;
|
||||
/** Connection id. */
|
||||
unsigned long connection_id;
|
||||
/** SQL command id. */
|
||||
enum_sql_command_t sql_command_id;
|
||||
/** Variable name. */
|
||||
MYSQL_LEX_CSTRING variable_name;
|
||||
/** Variable value. */
|
||||
MYSQL_LEX_CSTRING variable_value;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_server_startup_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_SERVER_STARTUP_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Occurs after all subsystem are initialized during system start. */
|
||||
MYSQL_AUDIT_SERVER_STARTUP_STARTUP = 1 << 0
|
||||
} mysql_event_server_startup_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_SERVER_STARTUP_ALL (MYSQL_AUDIT_SERVER_STARTUP_STARTUP)
|
||||
|
||||
/**
|
||||
@struct mysql_event_server_startup
|
||||
|
||||
Structure for MYSQL_AUDIT_SERVER_STARTUP_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_server_startup
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_server_startup_subclass_t event_subclass;
|
||||
/** Command line arguments. */
|
||||
const char **argv;
|
||||
/** Command line arguments count. */
|
||||
unsigned int argc;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_server_shutdown_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_SERVER_SHUTDOWN_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Occurs when global variable is set. */
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_SHUTDOWN = 1 << 0
|
||||
} mysql_event_server_shutdown_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_SERVER_SHUTDOWN_ALL (MYSQL_AUDIT_SERVER_SHUTDOWN_SHUTDOWN)
|
||||
|
||||
/**
|
||||
@enum mysql_server_shutdown_reason_t
|
||||
|
||||
Server shutdown reason.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** User requested shut down. */
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_REASON_SHUTDOWN,
|
||||
/** The server aborts. */
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_REASON_ABORT
|
||||
} mysql_server_shutdown_reason_t;
|
||||
|
||||
/**
|
||||
@struct mysql_event_server_shutdown
|
||||
|
||||
Structure for MYSQL_AUDIT_SERVER_SHUTDOWN_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_server_shutdown
|
||||
{
|
||||
/** Shutdown event. */
|
||||
mysql_event_server_shutdown_subclass_t event_subclass;
|
||||
/** Exit code associated with the shutdown event. */
|
||||
int exit_code;
|
||||
/** Shutdown reason. */
|
||||
mysql_server_shutdown_reason_t reason;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_command_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_COMMAND_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Command start event. */
|
||||
MYSQL_AUDIT_COMMAND_START = 1 << 0,
|
||||
/** Command end event. */
|
||||
MYSQL_AUDIT_COMMAND_END = 1 << 1
|
||||
} mysql_event_command_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_COMMAND_ALL (MYSQL_AUDIT_COMMAND_START | \
|
||||
MYSQL_AUDIT_COMMAND_END)
|
||||
/**
|
||||
@typedef enum_server_command_t
|
||||
|
||||
Server command type definition.
|
||||
*/
|
||||
typedef enum enum_server_command enum_server_command_t;
|
||||
|
||||
/**
|
||||
@struct mysql_event_command
|
||||
|
||||
Event for MYSQL_AUDIT_COMMAND_CLASS event class.
|
||||
Events generated as a result of RPC command requests.
|
||||
*/
|
||||
struct mysql_event_command
|
||||
{
|
||||
/** Command event subclass. */
|
||||
mysql_event_command_subclass_t event_subclass;
|
||||
/** Command event status. */
|
||||
int status;
|
||||
/** Connection id. */
|
||||
unsigned long connection_id;
|
||||
/** Command id. */
|
||||
enum_server_command_t command_id;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_query_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_QUERY_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Query start event. */
|
||||
MYSQL_AUDIT_QUERY_START = 1 << 0,
|
||||
/** Nested query start event. */
|
||||
MYSQL_AUDIT_QUERY_NESTED_START = 1 << 1,
|
||||
/** Query post parse event. */
|
||||
MYSQL_AUDIT_QUERY_STATUS_END = 1 << 2,
|
||||
/** Nested query status end event. */
|
||||
MYSQL_AUDIT_QUERY_NESTED_STATUS_END = 1 << 3
|
||||
} mysql_event_query_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_QUERY_ALL (MYSQL_AUDIT_QUERY_START | \
|
||||
MYSQL_AUDIT_QUERY_NESTED_START | \
|
||||
MYSQL_AUDIT_QUERY_STATUS_END | \
|
||||
MYSQL_AUDIT_QUERY_NESTED_STATUS_END)
|
||||
/**
|
||||
@struct mysql_event_command
|
||||
|
||||
Event for MYSQL_AUDIT_COMMAND_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_query
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_query_subclass_t event_subclass;
|
||||
/** Event status. */
|
||||
int status;
|
||||
/** Connection id. */
|
||||
unsigned long connection_id;
|
||||
/** SQL command id. */
|
||||
enum_sql_command_t sql_command_id;
|
||||
/** SQL query. */
|
||||
MYSQL_LEX_CSTRING query;
|
||||
/** SQL query charset. */
|
||||
const struct charset_info_st *query_charset;
|
||||
};
|
||||
|
||||
/**
|
||||
@enum mysql_event_stored_program_subclass_t
|
||||
|
||||
Events for MYSQL_AUDIT_STORED_PROGRAM_CLASS event class.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
/** Stored program execution event. */
|
||||
MYSQL_AUDIT_STORED_PROGRAM_EXECUTE = 1 << 0
|
||||
} mysql_event_stored_program_subclass_t;
|
||||
|
||||
#define MYSQL_AUDIT_STORED_PROGRAM_ALL (MYSQL_AUDIT_STORED_PROGRAM_EXECUTE)
|
||||
|
||||
/**
|
||||
@struct mysql_event_command
|
||||
|
||||
Event for MYSQL_AUDIT_COMMAND_CLASS event class.
|
||||
*/
|
||||
struct mysql_event_stored_program
|
||||
{
|
||||
/** Event subclass. */
|
||||
mysql_event_stored_program_subclass_t event_subclass;
|
||||
/** Connection id. */
|
||||
unsigned long connection_id;
|
||||
/** SQL command id. */
|
||||
enum_sql_command_t sql_command_id;
|
||||
/** SQL query text. */
|
||||
MYSQL_LEX_CSTRING query;
|
||||
/** SQL query charset. */
|
||||
const struct charset_info_st *query_charset;
|
||||
/** The Database the procedure is defined in. */
|
||||
MYSQL_LEX_CSTRING database;
|
||||
/** Name of the stored program. */
|
||||
MYSQL_LEX_CSTRING name;
|
||||
/** Stored program parameters. */
|
||||
void *parameters;
|
||||
};
|
||||
|
||||
#endif
|
|
@ -0,0 +1,514 @@
|
|||
#include "plugin.h"
|
||||
typedef void * MYSQL_PLUGIN;
|
||||
struct st_mysql_xid {
|
||||
long formatID;
|
||||
long gtrid_length;
|
||||
long bqual_length;
|
||||
char data[128];
|
||||
};
|
||||
typedef struct st_mysql_xid MYSQL_XID;
|
||||
enum enum_mysql_show_type
|
||||
{
|
||||
SHOW_UNDEF, SHOW_BOOL,
|
||||
SHOW_INT,
|
||||
SHOW_LONG,
|
||||
SHOW_LONGLONG,
|
||||
SHOW_CHAR, SHOW_CHAR_PTR,
|
||||
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
|
||||
};
|
||||
enum enum_mysql_show_scope
|
||||
{
|
||||
SHOW_SCOPE_UNDEF,
|
||||
SHOW_SCOPE_GLOBAL
|
||||
};
|
||||
struct st_mysql_show_var
|
||||
{
|
||||
const char *name;
|
||||
char *value;
|
||||
enum enum_mysql_show_type type;
|
||||
enum enum_mysql_show_scope scope;
|
||||
};
|
||||
typedef int (*mysql_show_var_func)(void*, struct st_mysql_show_var*, char *);
|
||||
struct st_mysql_sys_var;
|
||||
struct st_mysql_value;
|
||||
typedef int (*mysql_var_check_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *save, struct st_mysql_value *value);
|
||||
typedef void (*mysql_var_update_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *var_ptr, const void *save);
|
||||
struct st_mysql_plugin
|
||||
{
|
||||
int type;
|
||||
void *info;
|
||||
const char *name;
|
||||
const char *author;
|
||||
const char *descr;
|
||||
int license;
|
||||
int (*init)(MYSQL_PLUGIN);
|
||||
int (*deinit)(MYSQL_PLUGIN);
|
||||
unsigned int version;
|
||||
struct st_mysql_show_var *status_vars;
|
||||
struct st_mysql_sys_var **system_vars;
|
||||
void * __reserved1;
|
||||
unsigned long flags;
|
||||
};
|
||||
struct st_mysql_daemon
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_information_schema
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_storage_engine
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct handlerton;
|
||||
struct Mysql_replication {
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_value
|
||||
{
|
||||
int (*value_type)(struct st_mysql_value *);
|
||||
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
|
||||
int (*val_real)(struct st_mysql_value *, double *realbuf);
|
||||
int (*val_int)(struct st_mysql_value *, long long *intbuf);
|
||||
int (*is_unsigned)(struct st_mysql_value *);
|
||||
};
|
||||
int thd_in_lock_tables(const void* thd);
|
||||
int thd_tablespace_op(const void* thd);
|
||||
long long thd_test_options(const void* thd, long long test_options);
|
||||
int thd_sql_command(const void* thd);
|
||||
const char *set_thd_proc_info(void* thd, const char *info,
|
||||
const char *calling_func,
|
||||
const char *calling_file,
|
||||
const unsigned int calling_line);
|
||||
void **thd_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_storage_lock_wait(void* thd, long long value);
|
||||
int thd_tx_isolation(const void* thd);
|
||||
int thd_tx_is_read_only(const void* thd);
|
||||
void* thd_tx_arbitrate(void* requestor, void* holder);
|
||||
int thd_tx_priority(const void* thd);
|
||||
int thd_tx_is_dd_trx(const void* thd);
|
||||
char *thd_security_context(void* thd, char *buffer, size_t length,
|
||||
size_t max_query_len);
|
||||
void thd_inc_row_count(void* thd);
|
||||
int thd_allow_batch(void* thd);
|
||||
void thd_mark_transaction_to_rollback(void* thd, int all);
|
||||
int mysql_tmpfile(const char *prefix);
|
||||
int thd_killed(const void* thd);
|
||||
void thd_set_kill_status(const void* thd);
|
||||
void thd_binlog_pos(const void* thd,
|
||||
const char **file_var,
|
||||
unsigned long long *pos_var);
|
||||
unsigned long thd_get_thread_id(const void* thd);
|
||||
void thd_get_xid(const void* thd, MYSQL_XID *xid);
|
||||
void mysql_query_cache_invalidate4(void* thd,
|
||||
const char *key, unsigned int key_length,
|
||||
int using_trx);
|
||||
void *thd_get_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_set_ha_data(void* thd, const struct handlerton *hton,
|
||||
const void *ha_data);
|
||||
#include "mysql/mysql_lex_string.h"
|
||||
struct st_mysql_lex_string
|
||||
{
|
||||
char *str;
|
||||
size_t length;
|
||||
};
|
||||
typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
|
||||
struct st_mysql_const_lex_string
|
||||
{
|
||||
const char *str;
|
||||
size_t length;
|
||||
};
|
||||
typedef struct st_mysql_const_lex_string MYSQL_LEX_CSTRING;
|
||||
#include "my_command.h"
|
||||
enum enum_server_command
|
||||
{
|
||||
COM_SLEEP,
|
||||
COM_QUIT,
|
||||
COM_INIT_DB,
|
||||
COM_QUERY,
|
||||
COM_FIELD_LIST,
|
||||
COM_CREATE_DB,
|
||||
COM_DROP_DB,
|
||||
COM_REFRESH,
|
||||
COM_SHUTDOWN,
|
||||
COM_STATISTICS,
|
||||
COM_PROCESS_INFO,
|
||||
COM_CONNECT,
|
||||
COM_PROCESS_KILL,
|
||||
COM_DEBUG,
|
||||
COM_PING,
|
||||
COM_TIME,
|
||||
COM_DELAYED_INSERT,
|
||||
COM_CHANGE_USER,
|
||||
COM_BINLOG_DUMP,
|
||||
COM_TABLE_DUMP,
|
||||
COM_CONNECT_OUT,
|
||||
COM_REGISTER_SLAVE,
|
||||
COM_STMT_PREPARE,
|
||||
COM_STMT_EXECUTE,
|
||||
COM_STMT_SEND_LONG_DATA,
|
||||
COM_STMT_CLOSE,
|
||||
COM_STMT_RESET,
|
||||
COM_SET_OPTION,
|
||||
COM_STMT_FETCH,
|
||||
COM_DAEMON,
|
||||
COM_BINLOG_DUMP_GTID,
|
||||
COM_RESET_CONNECTION,
|
||||
COM_END
|
||||
};
|
||||
#include "my_sqlcommand.h"
|
||||
enum enum_sql_command {
|
||||
SQLCOM_SELECT,
|
||||
SQLCOM_CREATE_TABLE,
|
||||
SQLCOM_CREATE_INDEX,
|
||||
SQLCOM_ALTER_TABLE,
|
||||
SQLCOM_UPDATE,
|
||||
SQLCOM_INSERT,
|
||||
SQLCOM_INSERT_SELECT,
|
||||
SQLCOM_DELETE,
|
||||
SQLCOM_TRUNCATE,
|
||||
SQLCOM_DROP_TABLE,
|
||||
SQLCOM_DROP_INDEX,
|
||||
SQLCOM_SHOW_DATABASES,
|
||||
SQLCOM_SHOW_TABLES,
|
||||
SQLCOM_SHOW_FIELDS,
|
||||
SQLCOM_SHOW_KEYS,
|
||||
SQLCOM_SHOW_VARIABLES,
|
||||
SQLCOM_SHOW_STATUS,
|
||||
SQLCOM_SHOW_ENGINE_LOGS,
|
||||
SQLCOM_SHOW_ENGINE_STATUS,
|
||||
SQLCOM_SHOW_ENGINE_MUTEX,
|
||||
SQLCOM_SHOW_PROCESSLIST,
|
||||
SQLCOM_SHOW_MASTER_STAT,
|
||||
SQLCOM_SHOW_SLAVE_STAT,
|
||||
SQLCOM_SHOW_GRANTS,
|
||||
SQLCOM_SHOW_CREATE,
|
||||
SQLCOM_SHOW_CHARSETS,
|
||||
SQLCOM_SHOW_COLLATIONS,
|
||||
SQLCOM_SHOW_CREATE_DB,
|
||||
SQLCOM_SHOW_TABLE_STATUS,
|
||||
SQLCOM_SHOW_TRIGGERS,
|
||||
SQLCOM_LOAD,
|
||||
SQLCOM_SET_OPTION,
|
||||
SQLCOM_LOCK_TABLES,
|
||||
SQLCOM_UNLOCK_TABLES,
|
||||
SQLCOM_GRANT,
|
||||
SQLCOM_CHANGE_DB,
|
||||
SQLCOM_CREATE_DB,
|
||||
SQLCOM_DROP_DB,
|
||||
SQLCOM_ALTER_DB,
|
||||
SQLCOM_REPAIR,
|
||||
SQLCOM_REPLACE,
|
||||
SQLCOM_REPLACE_SELECT,
|
||||
SQLCOM_CREATE_FUNCTION,
|
||||
SQLCOM_DROP_FUNCTION,
|
||||
SQLCOM_REVOKE,
|
||||
SQLCOM_OPTIMIZE,
|
||||
SQLCOM_CHECK,
|
||||
SQLCOM_ASSIGN_TO_KEYCACHE,
|
||||
SQLCOM_PRELOAD_KEYS,
|
||||
SQLCOM_FLUSH,
|
||||
SQLCOM_KILL,
|
||||
SQLCOM_ANALYZE,
|
||||
SQLCOM_ROLLBACK,
|
||||
SQLCOM_ROLLBACK_TO_SAVEPOINT,
|
||||
SQLCOM_COMMIT,
|
||||
SQLCOM_SAVEPOINT,
|
||||
SQLCOM_RELEASE_SAVEPOINT,
|
||||
SQLCOM_SLAVE_START,
|
||||
SQLCOM_SLAVE_STOP,
|
||||
SQLCOM_START_GROUP_REPLICATION,
|
||||
SQLCOM_STOP_GROUP_REPLICATION,
|
||||
SQLCOM_BEGIN,
|
||||
SQLCOM_CHANGE_MASTER,
|
||||
SQLCOM_CHANGE_REPLICATION_FILTER,
|
||||
SQLCOM_RENAME_TABLE,
|
||||
SQLCOM_RESET,
|
||||
SQLCOM_PURGE,
|
||||
SQLCOM_PURGE_BEFORE,
|
||||
SQLCOM_SHOW_BINLOGS,
|
||||
SQLCOM_SHOW_OPEN_TABLES,
|
||||
SQLCOM_HA_OPEN,
|
||||
SQLCOM_HA_CLOSE,
|
||||
SQLCOM_HA_READ,
|
||||
SQLCOM_SHOW_SLAVE_HOSTS,
|
||||
SQLCOM_DELETE_MULTI,
|
||||
SQLCOM_UPDATE_MULTI,
|
||||
SQLCOM_SHOW_BINLOG_EVENTS,
|
||||
SQLCOM_DO,
|
||||
SQLCOM_SHOW_WARNS,
|
||||
SQLCOM_EMPTY_QUERY,
|
||||
SQLCOM_SHOW_ERRORS,
|
||||
SQLCOM_SHOW_STORAGE_ENGINES,
|
||||
SQLCOM_SHOW_PRIVILEGES,
|
||||
SQLCOM_HELP,
|
||||
SQLCOM_CREATE_USER,
|
||||
SQLCOM_DROP_USER,
|
||||
SQLCOM_RENAME_USER,
|
||||
SQLCOM_REVOKE_ALL,
|
||||
SQLCOM_CHECKSUM,
|
||||
SQLCOM_CREATE_PROCEDURE,
|
||||
SQLCOM_CREATE_SPFUNCTION,
|
||||
SQLCOM_CALL,
|
||||
SQLCOM_DROP_PROCEDURE,
|
||||
SQLCOM_ALTER_PROCEDURE,
|
||||
SQLCOM_ALTER_FUNCTION,
|
||||
SQLCOM_SHOW_CREATE_PROC,
|
||||
SQLCOM_SHOW_CREATE_FUNC,
|
||||
SQLCOM_SHOW_STATUS_PROC,
|
||||
SQLCOM_SHOW_STATUS_FUNC,
|
||||
SQLCOM_PREPARE,
|
||||
SQLCOM_EXECUTE,
|
||||
SQLCOM_DEALLOCATE_PREPARE,
|
||||
SQLCOM_CREATE_VIEW,
|
||||
SQLCOM_DROP_VIEW,
|
||||
SQLCOM_CREATE_TRIGGER,
|
||||
SQLCOM_DROP_TRIGGER,
|
||||
SQLCOM_XA_START,
|
||||
SQLCOM_XA_END,
|
||||
SQLCOM_XA_PREPARE,
|
||||
SQLCOM_XA_COMMIT,
|
||||
SQLCOM_XA_ROLLBACK,
|
||||
SQLCOM_XA_RECOVER,
|
||||
SQLCOM_SHOW_PROC_CODE,
|
||||
SQLCOM_SHOW_FUNC_CODE,
|
||||
SQLCOM_ALTER_TABLESPACE,
|
||||
SQLCOM_INSTALL_PLUGIN,
|
||||
SQLCOM_UNINSTALL_PLUGIN,
|
||||
SQLCOM_BINLOG_BASE64_EVENT,
|
||||
SQLCOM_SHOW_PLUGINS,
|
||||
SQLCOM_CREATE_SERVER,
|
||||
SQLCOM_DROP_SERVER,
|
||||
SQLCOM_ALTER_SERVER,
|
||||
SQLCOM_CREATE_EVENT,
|
||||
SQLCOM_ALTER_EVENT,
|
||||
SQLCOM_DROP_EVENT,
|
||||
SQLCOM_SHOW_CREATE_EVENT,
|
||||
SQLCOM_SHOW_EVENTS,
|
||||
SQLCOM_SHOW_CREATE_TRIGGER,
|
||||
SQLCOM_ALTER_DB_UPGRADE,
|
||||
SQLCOM_SHOW_PROFILE,
|
||||
SQLCOM_SHOW_PROFILES,
|
||||
SQLCOM_SIGNAL,
|
||||
SQLCOM_RESIGNAL,
|
||||
SQLCOM_SHOW_RELAYLOG_EVENTS,
|
||||
SQLCOM_GET_DIAGNOSTICS,
|
||||
SQLCOM_ALTER_USER,
|
||||
SQLCOM_EXPLAIN_OTHER,
|
||||
SQLCOM_SHOW_CREATE_USER,
|
||||
SQLCOM_SHUTDOWN,
|
||||
SQLCOM_ALTER_INSTANCE,
|
||||
SQLCOM_END
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_GENERAL_CLASS = 0,
|
||||
MYSQL_AUDIT_CONNECTION_CLASS = 1,
|
||||
MYSQL_AUDIT_PARSE_CLASS = 2,
|
||||
MYSQL_AUDIT_AUTHORIZATION_CLASS = 3,
|
||||
MYSQL_AUDIT_TABLE_ACCESS_CLASS = 4,
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_CLASS = 5,
|
||||
MYSQL_AUDIT_SERVER_STARTUP_CLASS = 6,
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_CLASS = 7,
|
||||
MYSQL_AUDIT_COMMAND_CLASS = 8,
|
||||
MYSQL_AUDIT_QUERY_CLASS = 9,
|
||||
MYSQL_AUDIT_STORED_PROGRAM_CLASS = 10,
|
||||
MYSQL_AUDIT_CLASS_MASK_SIZE
|
||||
} mysql_event_class_t;
|
||||
struct st_mysql_audit
|
||||
{
|
||||
int interface_version;
|
||||
void (*release_thd)(void*);
|
||||
int (*event_notify)(void*, mysql_event_class_t, const void *);
|
||||
unsigned long class_mask[MYSQL_AUDIT_CLASS_MASK_SIZE];
|
||||
};
|
||||
typedef enum enum_sql_command enum_sql_command_t;
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_GENERAL_LOG = 1 << 0,
|
||||
MYSQL_AUDIT_GENERAL_ERROR = 1 << 1,
|
||||
MYSQL_AUDIT_GENERAL_RESULT = 1 << 2,
|
||||
MYSQL_AUDIT_GENERAL_STATUS = 1 << 3
|
||||
} mysql_event_general_subclass_t;
|
||||
struct mysql_event_general
|
||||
{
|
||||
mysql_event_general_subclass_t event_subclass;
|
||||
int general_error_code;
|
||||
unsigned long general_thread_id;
|
||||
MYSQL_LEX_CSTRING general_user;
|
||||
MYSQL_LEX_CSTRING general_command;
|
||||
MYSQL_LEX_CSTRING general_query;
|
||||
struct charset_info_st *general_charset;
|
||||
unsigned long long general_time;
|
||||
unsigned long long general_rows;
|
||||
MYSQL_LEX_CSTRING general_host;
|
||||
MYSQL_LEX_CSTRING general_sql_command;
|
||||
MYSQL_LEX_CSTRING general_external_user;
|
||||
MYSQL_LEX_CSTRING general_ip;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_CONNECTION_CONNECT = 1 << 0,
|
||||
MYSQL_AUDIT_CONNECTION_DISCONNECT = 1 << 1,
|
||||
MYSQL_AUDIT_CONNECTION_CHANGE_USER = 1 << 2,
|
||||
MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE = 1 << 3
|
||||
} mysql_event_connection_subclass_t;
|
||||
struct mysql_event_connection
|
||||
{
|
||||
mysql_event_connection_subclass_t event_subclass;
|
||||
int status;
|
||||
unsigned long connection_id;
|
||||
MYSQL_LEX_CSTRING user;
|
||||
MYSQL_LEX_CSTRING priv_user;
|
||||
MYSQL_LEX_CSTRING external_user;
|
||||
MYSQL_LEX_CSTRING proxy_user;
|
||||
MYSQL_LEX_CSTRING host;
|
||||
MYSQL_LEX_CSTRING ip;
|
||||
MYSQL_LEX_CSTRING database;
|
||||
int connection_type;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_PARSE_PREPARSE = 1 << 0,
|
||||
MYSQL_AUDIT_PARSE_POSTPARSE = 1 << 1
|
||||
} mysql_event_parse_subclass_t;
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_PARSE_REWRITE_PLUGIN_NONE = 0,
|
||||
MYSQL_AUDIT_PARSE_REWRITE_PLUGIN_QUERY_REWRITTEN = 1 << 0,
|
||||
MYSQL_AUDIT_PARSE_REWRITE_PLUGIN_IS_PREPARED_STATEMENT = 1 << 1
|
||||
} mysql_event_parse_rewrite_plugin_flag;
|
||||
struct mysql_event_parse
|
||||
{
|
||||
mysql_event_parse_subclass_t event_subclass;
|
||||
mysql_event_parse_rewrite_plugin_flag *flags;
|
||||
MYSQL_LEX_CSTRING query;
|
||||
MYSQL_LEX_CSTRING *rewritten_query;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_AUTHORIZATION_USER = 1 << 0,
|
||||
MYSQL_AUDIT_AUTHORIZATION_DB = 1 << 1,
|
||||
MYSQL_AUDIT_AUTHORIZATION_TABLE = 1 << 2,
|
||||
MYSQL_AUDIT_AUTHORIZATION_COLUMN = 1 << 3,
|
||||
MYSQL_AUDIT_AUTHORIZATION_PROCEDURE = 1 << 4,
|
||||
MYSQL_AUDIT_AUTHORIZATION_PROXY = 1 << 5
|
||||
} mysql_event_authorization_subclass_t;
|
||||
struct mysql_event_authorization
|
||||
{
|
||||
mysql_event_authorization_subclass_t event_subclass;
|
||||
int status;
|
||||
unsigned int connection_id;
|
||||
enum_sql_command_t sql_command_id;
|
||||
MYSQL_LEX_CSTRING query;
|
||||
const struct charset_info_st *query_charset;
|
||||
MYSQL_LEX_CSTRING database;
|
||||
MYSQL_LEX_CSTRING table;
|
||||
MYSQL_LEX_CSTRING object;
|
||||
unsigned long requested_privilege;
|
||||
unsigned long granted_privilege;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_TABLE_ACCESS_READ = 1 << 0,
|
||||
MYSQL_AUDIT_TABLE_ACCESS_INSERT = 1 << 1,
|
||||
MYSQL_AUDIT_TABLE_ACCESS_UPDATE = 1 << 2,
|
||||
MYSQL_AUDIT_TABLE_ACCESS_DELETE = 1 << 3
|
||||
} mysql_event_table_access_subclass_t;
|
||||
struct mysql_event_table_access
|
||||
{
|
||||
mysql_event_table_access_subclass_t event_subclass;
|
||||
unsigned long connection_id;
|
||||
enum_sql_command_t sql_command_id;
|
||||
MYSQL_LEX_CSTRING query;
|
||||
const struct charset_info_st *query_charset;
|
||||
MYSQL_LEX_CSTRING table_database;
|
||||
MYSQL_LEX_CSTRING table_name;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_GET = 1 << 0,
|
||||
MYSQL_AUDIT_GLOBAL_VARIABLE_SET = 1 << 1
|
||||
} mysql_event_global_variable_subclass_t;
|
||||
struct mysql_event_global_variable
|
||||
{
|
||||
mysql_event_global_variable_subclass_t event_subclass;
|
||||
unsigned long connection_id;
|
||||
enum_sql_command_t sql_command_id;
|
||||
MYSQL_LEX_CSTRING variable_name;
|
||||
MYSQL_LEX_CSTRING variable_value;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_SERVER_STARTUP_STARTUP = 1 << 0
|
||||
} mysql_event_server_startup_subclass_t;
|
||||
struct mysql_event_server_startup
|
||||
{
|
||||
mysql_event_server_startup_subclass_t event_subclass;
|
||||
const char **argv;
|
||||
unsigned int argc;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_SHUTDOWN = 1 << 0
|
||||
} mysql_event_server_shutdown_subclass_t;
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_REASON_SHUTDOWN,
|
||||
MYSQL_AUDIT_SERVER_SHUTDOWN_REASON_ABORT
|
||||
} mysql_server_shutdown_reason_t;
|
||||
struct mysql_event_server_shutdown
|
||||
{
|
||||
mysql_event_server_shutdown_subclass_t event_subclass;
|
||||
int exit_code;
|
||||
mysql_server_shutdown_reason_t reason;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_COMMAND_START = 1 << 0,
|
||||
MYSQL_AUDIT_COMMAND_END = 1 << 1
|
||||
} mysql_event_command_subclass_t;
|
||||
typedef enum enum_server_command enum_server_command_t;
|
||||
struct mysql_event_command
|
||||
{
|
||||
mysql_event_command_subclass_t event_subclass;
|
||||
int status;
|
||||
unsigned long connection_id;
|
||||
enum_server_command_t command_id;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_QUERY_START = 1 << 0,
|
||||
MYSQL_AUDIT_QUERY_NESTED_START = 1 << 1,
|
||||
MYSQL_AUDIT_QUERY_STATUS_END = 1 << 2,
|
||||
MYSQL_AUDIT_QUERY_NESTED_STATUS_END = 1 << 3
|
||||
} mysql_event_query_subclass_t;
|
||||
struct mysql_event_query
|
||||
{
|
||||
mysql_event_query_subclass_t event_subclass;
|
||||
int status;
|
||||
unsigned long connection_id;
|
||||
enum_sql_command_t sql_command_id;
|
||||
MYSQL_LEX_CSTRING query;
|
||||
const struct charset_info_st *query_charset;
|
||||
};
|
||||
typedef enum
|
||||
{
|
||||
MYSQL_AUDIT_STORED_PROGRAM_EXECUTE = 1 << 0
|
||||
} mysql_event_stored_program_subclass_t;
|
||||
struct mysql_event_stored_program
|
||||
{
|
||||
mysql_event_stored_program_subclass_t event_subclass;
|
||||
unsigned long connection_id;
|
||||
enum_sql_command_t sql_command_id;
|
||||
MYSQL_LEX_CSTRING query;
|
||||
const struct charset_info_st *query_charset;
|
||||
MYSQL_LEX_CSTRING database;
|
||||
MYSQL_LEX_CSTRING name;
|
||||
void *parameters;
|
||||
};
|
|
@ -0,0 +1,185 @@
|
|||
#ifndef MYSQL_PLUGIN_AUTH_INCLUDED
|
||||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file
|
||||
|
||||
Authentication Plugin API.
|
||||
|
||||
This file defines the API for server authentication plugins.
|
||||
*/
|
||||
|
||||
#define MYSQL_PLUGIN_AUTH_INCLUDED
|
||||
|
||||
#include <mysql/plugin.h>
|
||||
|
||||
#define MYSQL_AUTHENTICATION_INTERFACE_VERSION 0x0101
|
||||
|
||||
#include "plugin_auth_common.h"
|
||||
|
||||
/* defines for MYSQL_SERVER_AUTH_INFO.password_used */
|
||||
|
||||
#define PASSWORD_USED_NO 0
|
||||
#define PASSWORD_USED_YES 1
|
||||
#define PASSWORD_USED_NO_MENTION 2
|
||||
|
||||
/* Authentication flags */
|
||||
|
||||
#define AUTH_FLAG_PRIVILEGED_USER_FOR_PASSWORD_CHANGE (1L << 0)
|
||||
#define AUTH_FLAG_USES_INTERNAL_STORAGE (1L << 1)
|
||||
|
||||
/**
|
||||
Provides server plugin access to authentication information
|
||||
*/
|
||||
typedef struct st_mysql_server_auth_info
|
||||
{
|
||||
/**
|
||||
User name as sent by the client and shown in USER().
|
||||
NULL if the client packet with the user name was not received yet.
|
||||
*/
|
||||
char *user_name;
|
||||
|
||||
/**
|
||||
Length of user_name
|
||||
*/
|
||||
unsigned int user_name_length;
|
||||
|
||||
/**
|
||||
A corresponding column value from the mysql.user table for the
|
||||
matching account name
|
||||
*/
|
||||
const char *auth_string;
|
||||
|
||||
/**
|
||||
Length of auth_string
|
||||
*/
|
||||
unsigned long auth_string_length;
|
||||
|
||||
/**
|
||||
Matching account name as found in the mysql.user table.
|
||||
A plugin can override it with another name that will be
|
||||
used by MySQL for authorization, and shown in CURRENT_USER()
|
||||
*/
|
||||
char authenticated_as[MYSQL_USERNAME_LENGTH+1];
|
||||
|
||||
|
||||
/**
|
||||
The unique user name that was used by the plugin to authenticate.
|
||||
Plugins should put null-terminated UTF-8 here.
|
||||
Available through the @@EXTERNAL_USER variable.
|
||||
*/
|
||||
char external_user[512];
|
||||
|
||||
/**
|
||||
This only affects the "Authentication failed. Password used: %s"
|
||||
error message. has the following values :
|
||||
0 : %s will be NO.
|
||||
1 : %s will be YES.
|
||||
2 : there will be no %s.
|
||||
Set it as appropriate or ignore at will.
|
||||
*/
|
||||
int password_used;
|
||||
|
||||
/**
|
||||
Set to the name of the connected client host, if it can be resolved,
|
||||
or to its IP address otherwise.
|
||||
*/
|
||||
const char *host_or_ip;
|
||||
|
||||
/**
|
||||
Length of host_or_ip
|
||||
*/
|
||||
unsigned int host_or_ip_length;
|
||||
|
||||
} MYSQL_SERVER_AUTH_INFO;
|
||||
|
||||
/**
|
||||
Server authentication plugin descriptor
|
||||
*/
|
||||
struct st_mysql_auth
|
||||
{
|
||||
int interface_version; /** version plugin uses */
|
||||
/**
|
||||
A plugin that a client must use for authentication with this server
|
||||
plugin. Can be NULL to mean "any plugin".
|
||||
*/
|
||||
const char *client_auth_plugin;
|
||||
/**
|
||||
Function provided by the plugin which should perform authentication (using
|
||||
the vio functions if necessary) and return 0 if successful. The plugin can
|
||||
also fill the info.authenticated_as field if a different username should be
|
||||
used for authorization.
|
||||
*/
|
||||
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, MYSQL_SERVER_AUTH_INFO *info);
|
||||
/**
|
||||
New plugin API to generate password digest out of authentication string.
|
||||
This function will first invoke a service to check for validity of the
|
||||
password based on the policies defined and then generate encrypted hash
|
||||
|
||||
@param[OUT] outbuf A buffer provided by server which will hold the
|
||||
authentication string generated by plugin.
|
||||
@param[INOUT] outbuflen Length of server provided buffer as IN param and
|
||||
length of plugin generated string as OUT param.
|
||||
@param[IN] inbuf auth string provided by user.
|
||||
@param[IN] inbuflen auth string length.
|
||||
|
||||
@retval 0 OK
|
||||
1 ERROR
|
||||
|
||||
*/
|
||||
int (*generate_authentication_string)(char *outbuf,
|
||||
unsigned int *outbuflen, const char *inbuf, unsigned int inbuflen);
|
||||
/**
|
||||
Plugin API to validate password digest.
|
||||
|
||||
@param[IN] inbuf hash string to be validated.
|
||||
@param[IN] buflen hash string length.
|
||||
|
||||
@retval 0 OK
|
||||
1 ERROR
|
||||
|
||||
*/
|
||||
int (*validate_authentication_string)(char* const inbuf, unsigned int buflen);
|
||||
/**
|
||||
Plugin API to convert scrambled password to binary form
|
||||
based on scramble type.
|
||||
|
||||
@param[IN] password The password hash containing the salt.
|
||||
@param[IN] password_len The length of the password hash.
|
||||
@param[INOUT] salt Used as password hash based on the
|
||||
authentication plugin.
|
||||
@param[INOUT] salt_len The length of salt.
|
||||
|
||||
@retval 0 OK
|
||||
1 ERROR
|
||||
|
||||
*/
|
||||
int (*set_salt)(const char *password, unsigned int password_len,
|
||||
unsigned char* salt, unsigned char *salt_len);
|
||||
/**
|
||||
Authentication plugin capabilities
|
||||
*/
|
||||
const unsigned long authentication_flags;
|
||||
};
|
||||
#endif
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
#include <mysql/plugin.h>
|
||||
typedef void * MYSQL_PLUGIN;
|
||||
struct st_mysql_xid {
|
||||
long formatID;
|
||||
long gtrid_length;
|
||||
long bqual_length;
|
||||
char data[128];
|
||||
};
|
||||
typedef struct st_mysql_xid MYSQL_XID;
|
||||
enum enum_mysql_show_type
|
||||
{
|
||||
SHOW_UNDEF, SHOW_BOOL,
|
||||
SHOW_INT,
|
||||
SHOW_LONG,
|
||||
SHOW_LONGLONG,
|
||||
SHOW_CHAR, SHOW_CHAR_PTR,
|
||||
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
|
||||
};
|
||||
enum enum_mysql_show_scope
|
||||
{
|
||||
SHOW_SCOPE_UNDEF,
|
||||
SHOW_SCOPE_GLOBAL
|
||||
};
|
||||
struct st_mysql_show_var
|
||||
{
|
||||
const char *name;
|
||||
char *value;
|
||||
enum enum_mysql_show_type type;
|
||||
enum enum_mysql_show_scope scope;
|
||||
};
|
||||
typedef int (*mysql_show_var_func)(void*, struct st_mysql_show_var*, char *);
|
||||
struct st_mysql_sys_var;
|
||||
struct st_mysql_value;
|
||||
typedef int (*mysql_var_check_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *save, struct st_mysql_value *value);
|
||||
typedef void (*mysql_var_update_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *var_ptr, const void *save);
|
||||
struct st_mysql_plugin
|
||||
{
|
||||
int type;
|
||||
void *info;
|
||||
const char *name;
|
||||
const char *author;
|
||||
const char *descr;
|
||||
int license;
|
||||
int (*init)(MYSQL_PLUGIN);
|
||||
int (*deinit)(MYSQL_PLUGIN);
|
||||
unsigned int version;
|
||||
struct st_mysql_show_var *status_vars;
|
||||
struct st_mysql_sys_var **system_vars;
|
||||
void * __reserved1;
|
||||
unsigned long flags;
|
||||
};
|
||||
struct st_mysql_daemon
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_information_schema
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_storage_engine
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct handlerton;
|
||||
struct Mysql_replication {
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_value
|
||||
{
|
||||
int (*value_type)(struct st_mysql_value *);
|
||||
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
|
||||
int (*val_real)(struct st_mysql_value *, double *realbuf);
|
||||
int (*val_int)(struct st_mysql_value *, long long *intbuf);
|
||||
int (*is_unsigned)(struct st_mysql_value *);
|
||||
};
|
||||
int thd_in_lock_tables(const void* thd);
|
||||
int thd_tablespace_op(const void* thd);
|
||||
long long thd_test_options(const void* thd, long long test_options);
|
||||
int thd_sql_command(const void* thd);
|
||||
const char *set_thd_proc_info(void* thd, const char *info,
|
||||
const char *calling_func,
|
||||
const char *calling_file,
|
||||
const unsigned int calling_line);
|
||||
void **thd_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_storage_lock_wait(void* thd, long long value);
|
||||
int thd_tx_isolation(const void* thd);
|
||||
int thd_tx_is_read_only(const void* thd);
|
||||
void* thd_tx_arbitrate(void* requestor, void* holder);
|
||||
int thd_tx_priority(const void* thd);
|
||||
int thd_tx_is_dd_trx(const void* thd);
|
||||
char *thd_security_context(void* thd, char *buffer, size_t length,
|
||||
size_t max_query_len);
|
||||
void thd_inc_row_count(void* thd);
|
||||
int thd_allow_batch(void* thd);
|
||||
void thd_mark_transaction_to_rollback(void* thd, int all);
|
||||
int mysql_tmpfile(const char *prefix);
|
||||
int thd_killed(const void* thd);
|
||||
void thd_set_kill_status(const void* thd);
|
||||
void thd_binlog_pos(const void* thd,
|
||||
const char **file_var,
|
||||
unsigned long long *pos_var);
|
||||
unsigned long thd_get_thread_id(const void* thd);
|
||||
void thd_get_xid(const void* thd, MYSQL_XID *xid);
|
||||
void mysql_query_cache_invalidate4(void* thd,
|
||||
const char *key, unsigned int key_length,
|
||||
int using_trx);
|
||||
void *thd_get_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_set_ha_data(void* thd, const struct handlerton *hton,
|
||||
const void *ha_data);
|
||||
#include "plugin_auth_common.h"
|
||||
typedef struct st_plugin_vio_info
|
||||
{
|
||||
enum { MYSQL_VIO_INVALID, MYSQL_VIO_TCP, MYSQL_VIO_SOCKET,
|
||||
MYSQL_VIO_PIPE, MYSQL_VIO_MEMORY } protocol;
|
||||
int socket;
|
||||
} MYSQL_PLUGIN_VIO_INFO;
|
||||
typedef struct st_plugin_vio
|
||||
{
|
||||
int (*read_packet)(struct st_plugin_vio *vio,
|
||||
unsigned char **buf);
|
||||
int (*write_packet)(struct st_plugin_vio *vio,
|
||||
const unsigned char *packet,
|
||||
int packet_len);
|
||||
void (*info)(struct st_plugin_vio *vio, struct st_plugin_vio_info *info);
|
||||
} MYSQL_PLUGIN_VIO;
|
||||
typedef struct st_mysql_server_auth_info
|
||||
{
|
||||
char *user_name;
|
||||
unsigned int user_name_length;
|
||||
const char *auth_string;
|
||||
unsigned long auth_string_length;
|
||||
char authenticated_as[96 +1];
|
||||
char external_user[512];
|
||||
int password_used;
|
||||
const char *host_or_ip;
|
||||
unsigned int host_or_ip_length;
|
||||
} MYSQL_SERVER_AUTH_INFO;
|
||||
struct st_mysql_auth
|
||||
{
|
||||
int interface_version;
|
||||
const char *client_auth_plugin;
|
||||
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, MYSQL_SERVER_AUTH_INFO *info);
|
||||
int (*generate_authentication_string)(char *outbuf,
|
||||
unsigned int *outbuflen, const char *inbuf, unsigned int inbuflen);
|
||||
int (*validate_authentication_string)(char* const inbuf, unsigned int buflen);
|
||||
int (*set_salt)(const char *password, unsigned int password_len,
|
||||
unsigned char* salt, unsigned char *salt_len);
|
||||
const unsigned long authentication_flags;
|
||||
};
|
|
@ -27,7 +27,7 @@
|
|||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file include/mysql/plugin_auth_common.h
|
||||
@file
|
||||
|
||||
This file defines constants and data structures that are the same for
|
||||
both client- and server-side authentication plugins.
|
||||
|
@ -94,12 +94,7 @@
|
|||
or not.
|
||||
*/
|
||||
#define CR_OK_HANDSHAKE_COMPLETE -2
|
||||
/**
|
||||
Authentication was successful with limited operations.
|
||||
It means that the both client and server side plugins decided to allow
|
||||
authentication with very limited operations ALTER USER to do registration.
|
||||
*/
|
||||
#define CR_OK_AUTH_IN_SANDBOX_MODE -3
|
||||
|
||||
/**
|
||||
Flag to be passed back to server from authentication plugins via
|
||||
authenticated_as when proxy mapping should be done by the server.
|
||||
|
@ -110,78 +105,51 @@ authenticated_as when proxy mapping should be done by the server.
|
|||
We need HANDLE definition if on Windows. Define WIN32_LEAN_AND_MEAN (if
|
||||
not already done) to minimize amount of imported declarations.
|
||||
*/
|
||||
#if defined(_WIN32) && !defined(MYSQL_ABI_CHECK)
|
||||
#ifdef _WIN32
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
struct MYSQL_PLUGIN_VIO_INFO {
|
||||
enum {
|
||||
MYSQL_VIO_INVALID,
|
||||
MYSQL_VIO_TCP,
|
||||
MYSQL_VIO_SOCKET,
|
||||
MYSQL_VIO_PIPE,
|
||||
MYSQL_VIO_MEMORY
|
||||
} protocol;
|
||||
int socket; /**< it's set, if the protocol is SOCKET or TCP */
|
||||
#if defined(_WIN32) && !defined(MYSQL_ABI_CHECK)
|
||||
HANDLE handle; /**< it's set, if the protocol is PIPE or MEMORY */
|
||||
typedef struct st_plugin_vio_info
|
||||
{
|
||||
enum { MYSQL_VIO_INVALID, MYSQL_VIO_TCP, MYSQL_VIO_SOCKET,
|
||||
MYSQL_VIO_PIPE, MYSQL_VIO_MEMORY } protocol;
|
||||
int socket; /**< it's set, if the protocol is SOCKET or TCP */
|
||||
#ifdef _WIN32
|
||||
HANDLE handle; /**< it's set, if the protocol is PIPE or MEMORY */
|
||||
#endif
|
||||
};
|
||||
|
||||
/* state of an asynchronous operation */
|
||||
enum net_async_status {
|
||||
NET_ASYNC_COMPLETE = 0,
|
||||
NET_ASYNC_NOT_READY,
|
||||
NET_ASYNC_ERROR,
|
||||
NET_ASYNC_COMPLETE_NO_MORE_RESULTS
|
||||
};
|
||||
} MYSQL_PLUGIN_VIO_INFO;
|
||||
|
||||
/**
|
||||
Provides plugin access to communication channel
|
||||
*/
|
||||
typedef struct MYSQL_PLUGIN_VIO {
|
||||
typedef struct st_plugin_vio
|
||||
{
|
||||
/**
|
||||
Plugin provides a pointer reference and this function sets it to the
|
||||
contents of any incoming packet. Returns the packet length, or -1 if
|
||||
the plugin should terminate.
|
||||
*/
|
||||
int (*read_packet)(struct MYSQL_PLUGIN_VIO *vio, unsigned char **buf);
|
||||
|
||||
int (*read_packet)(struct st_plugin_vio *vio,
|
||||
unsigned char **buf);
|
||||
|
||||
/**
|
||||
Plugin provides a buffer with data and the length and this
|
||||
function sends it as a packet. Returns 0 on success, 1 on failure.
|
||||
*/
|
||||
int (*write_packet)(struct MYSQL_PLUGIN_VIO *vio, const unsigned char *packet,
|
||||
int (*write_packet)(struct st_plugin_vio *vio,
|
||||
const unsigned char *packet,
|
||||
int packet_len);
|
||||
|
||||
/**
|
||||
Fills in a MYSQL_PLUGIN_VIO_INFO structure, providing the information
|
||||
Fills in a st_plugin_vio_info structure, providing the information
|
||||
about the connection.
|
||||
*/
|
||||
void (*info)(struct MYSQL_PLUGIN_VIO *vio,
|
||||
struct MYSQL_PLUGIN_VIO_INFO *info);
|
||||
|
||||
/**
|
||||
Non blocking version of read_packet. This function points buf to starting
|
||||
position of incoming packet. When this function returns NET_ASYNC_NOT_READY
|
||||
plugin should call this function again until all incoming packets are read.
|
||||
If return code is NET_ASYNC_COMPLETE, plugin can do further processing of
|
||||
read packets.
|
||||
*/
|
||||
enum net_async_status (*read_packet_nonblocking)(struct MYSQL_PLUGIN_VIO *vio,
|
||||
unsigned char **buf,
|
||||
int *result);
|
||||
/**
|
||||
Non blocking version of write_packet. Sends data available in pkt of length
|
||||
pkt_len to server in asynchronous way.
|
||||
*/
|
||||
enum net_async_status (*write_packet_nonblocking)(
|
||||
struct MYSQL_PLUGIN_VIO *vio, const unsigned char *pkt, int pkt_len,
|
||||
int *result);
|
||||
void (*info)(struct st_plugin_vio *vio, struct st_plugin_vio_info *info);
|
||||
|
||||
} MYSQL_PLUGIN_VIO;
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
@ -0,0 +1,221 @@
|
|||
/* Copyright (c) 2005, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef _my_plugin_ftparser_h
|
||||
#define _my_plugin_ftparser_h
|
||||
|
||||
#include "plugin.h"
|
||||
|
||||
/*************************************************************************
|
||||
API for Full-text parser plugin. (MYSQL_FTPARSER_PLUGIN)
|
||||
*/
|
||||
|
||||
|
||||
/* Parsing modes. Set in MYSQL_FTPARSER_PARAM::mode */
|
||||
enum enum_ftparser_mode
|
||||
{
|
||||
/*
|
||||
Fast and simple mode. This mode is used for indexing, and natural
|
||||
language queries.
|
||||
|
||||
The parser is expected to return only those words that go into the
|
||||
index. Stopwords or too short/long words should not be returned. The
|
||||
'boolean_info' argument of mysql_add_word() does not have to be set.
|
||||
*/
|
||||
MYSQL_FTPARSER_SIMPLE_MODE= 0,
|
||||
|
||||
/*
|
||||
Parse with stopwords mode. This mode is used in boolean searches for
|
||||
"phrase matching."
|
||||
|
||||
The parser is not allowed to ignore words in this mode. Every word
|
||||
should be returned, including stopwords and words that are too short
|
||||
or long. The 'boolean_info' argument of mysql_add_word() does not
|
||||
have to be set.
|
||||
*/
|
||||
MYSQL_FTPARSER_WITH_STOPWORDS= 1,
|
||||
|
||||
/*
|
||||
Parse in boolean mode. This mode is used to parse a boolean query string.
|
||||
|
||||
The parser should provide a valid MYSQL_FTPARSER_BOOLEAN_INFO
|
||||
structure in the 'boolean_info' argument to mysql_add_word().
|
||||
Usually that means that the parser should recognize boolean operators
|
||||
in the parsing stream and set appropriate fields in
|
||||
MYSQL_FTPARSER_BOOLEAN_INFO structure accordingly. As for
|
||||
MYSQL_FTPARSER_WITH_STOPWORDS mode, no word should be ignored.
|
||||
Instead, use FT_TOKEN_STOPWORD for the token type of such a word.
|
||||
*/
|
||||
MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2
|
||||
};
|
||||
|
||||
/*
|
||||
Token types for boolean mode searching (used for the type member of
|
||||
MYSQL_FTPARSER_BOOLEAN_INFO struct)
|
||||
|
||||
FT_TOKEN_EOF: End of data.
|
||||
FT_TOKEN_WORD: Regular word.
|
||||
FT_TOKEN_LEFT_PAREN: Left parenthesis (start of group/sub-expression).
|
||||
FT_TOKEN_RIGHT_PAREN: Right parenthesis (end of group/sub-expression).
|
||||
FT_TOKEN_STOPWORD: Stopword.
|
||||
*/
|
||||
|
||||
enum enum_ft_token_type
|
||||
{
|
||||
FT_TOKEN_EOF= 0,
|
||||
FT_TOKEN_WORD= 1,
|
||||
FT_TOKEN_LEFT_PAREN= 2,
|
||||
FT_TOKEN_RIGHT_PAREN= 3,
|
||||
FT_TOKEN_STOPWORD= 4
|
||||
};
|
||||
|
||||
/*
|
||||
This structure is used in boolean search mode only. It conveys
|
||||
boolean-mode metadata to the MySQL search engine for every word in
|
||||
the search query. A valid instance of this structure must be filled
|
||||
in by the plugin parser and passed as an argument in the call to
|
||||
mysql_add_word (the callback function in the MYSQL_FTPARSER_PARAM
|
||||
structure) when a query is parsed in boolean mode.
|
||||
|
||||
type: The token type. Should be one of the enum_ft_token_type values.
|
||||
|
||||
yesno: Whether the word must be present for a match to occur:
|
||||
>0 Must be present
|
||||
<0 Must not be present
|
||||
0 Neither; the word is optional but its presence increases the relevance
|
||||
With the default settings of the ft_boolean_syntax system variable,
|
||||
>0 corresponds to the '+' operator, <0 corrresponds to the '-' operator,
|
||||
and 0 means neither operator was used.
|
||||
|
||||
weight_adjust: A weighting factor that determines how much a match
|
||||
for the word counts. Positive values increase, negative - decrease the
|
||||
relative word's importance in the query.
|
||||
|
||||
wasign: The sign of the word's weight in the query. If it's non-negative
|
||||
the match for the word will increase document relevance, if it's
|
||||
negative - decrease (the word becomes a "noise word", the less of it the
|
||||
better).
|
||||
|
||||
trunc: Corresponds to the '*' operator in the default setting of the
|
||||
ft_boolean_syntax system variable.
|
||||
|
||||
position: Start position in bytes of the word in the document, used by InnoDB FTS.
|
||||
*/
|
||||
|
||||
typedef struct st_mysql_ftparser_boolean_info
|
||||
{
|
||||
enum enum_ft_token_type type;
|
||||
int yesno;
|
||||
int weight_adjust;
|
||||
char wasign;
|
||||
char trunc;
|
||||
int position;
|
||||
/* These are parser state and must be removed. */
|
||||
char prev;
|
||||
char *quot;
|
||||
} MYSQL_FTPARSER_BOOLEAN_INFO;
|
||||
|
||||
/*
|
||||
The following flag means that buffer with a string (document, word)
|
||||
may be overwritten by the caller before the end of the parsing (that is
|
||||
before st_mysql_ftparser::deinit() call). If one needs the string
|
||||
to survive between two successive calls of the parsing function, she
|
||||
needs to save a copy of it. The flag may be set by MySQL before calling
|
||||
st_mysql_ftparser::parse(), or it may be set by a plugin before calling
|
||||
st_mysql_ftparser_param::mysql_parse() or
|
||||
st_mysql_ftparser_param::mysql_add_word().
|
||||
*/
|
||||
#define MYSQL_FTFLAGS_NEED_COPY 1
|
||||
|
||||
/*
|
||||
An argument of the full-text parser plugin. This structure is
|
||||
filled in by MySQL server and passed to the parsing function of the
|
||||
plugin as an in/out parameter.
|
||||
|
||||
mysql_parse: A pointer to the built-in parser implementation of the
|
||||
server. It's set by the server and can be used by the parser plugin
|
||||
to invoke the MySQL default parser. If plugin's role is to extract
|
||||
textual data from .doc, .pdf or .xml content, it might extract
|
||||
plaintext from the content, and then pass the text to the default
|
||||
MySQL parser to be parsed.
|
||||
|
||||
mysql_add_word: A server callback to add a new word. When parsing
|
||||
a document, the server sets this to point at a function that adds
|
||||
the word to MySQL full-text index. When parsing a search query,
|
||||
this function will add the new word to the list of words to search
|
||||
for. The boolean_info argument can be NULL for all cases except
|
||||
when mode is MYSQL_FTPARSER_FULL_BOOLEAN_INFO.
|
||||
|
||||
ftparser_state: A generic pointer. The plugin can set it to point
|
||||
to information to be used internally for its own purposes.
|
||||
|
||||
mysql_ftparam: This is set by the server. It is used by MySQL functions
|
||||
called via mysql_parse() and mysql_add_word() callback. The plugin
|
||||
should not modify it.
|
||||
|
||||
cs: Information about the character set of the document or query string.
|
||||
|
||||
doc: A pointer to the document or query string to be parsed.
|
||||
|
||||
length: Length of the document or query string, in bytes.
|
||||
|
||||
flags: See MYSQL_FTFLAGS_* constants above.
|
||||
|
||||
mode: The parsing mode. With boolean operators, with stopwords, or
|
||||
nothing. See enum_ftparser_mode above.
|
||||
*/
|
||||
|
||||
typedef struct st_mysql_ftparser_param
|
||||
{
|
||||
int (*mysql_parse)(struct st_mysql_ftparser_param *,
|
||||
char *doc, int doc_len);
|
||||
int (*mysql_add_word)(struct st_mysql_ftparser_param *,
|
||||
char *word, int word_len,
|
||||
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info);
|
||||
void *ftparser_state;
|
||||
void *mysql_ftparam;
|
||||
const struct charset_info_st *cs;
|
||||
char *doc;
|
||||
int length;
|
||||
int flags;
|
||||
enum enum_ftparser_mode mode;
|
||||
} MYSQL_FTPARSER_PARAM;
|
||||
|
||||
/*
|
||||
Full-text parser descriptor.
|
||||
|
||||
interface_version is, e.g., MYSQL_FTPARSER_INTERFACE_VERSION.
|
||||
The parsing, initialization, and deinitialization functions are
|
||||
invoked per SQL statement for which the parser is used.
|
||||
*/
|
||||
|
||||
struct st_mysql_ftparser
|
||||
{
|
||||
int interface_version;
|
||||
int (*parse)(MYSQL_FTPARSER_PARAM *param);
|
||||
int (*init)(MYSQL_FTPARSER_PARAM *param);
|
||||
int (*deinit)(MYSQL_FTPARSER_PARAM *param);
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
#include "plugin.h"
|
||||
typedef void * MYSQL_PLUGIN;
|
||||
struct st_mysql_xid {
|
||||
long formatID;
|
||||
long gtrid_length;
|
||||
long bqual_length;
|
||||
char data[128];
|
||||
};
|
||||
typedef struct st_mysql_xid MYSQL_XID;
|
||||
enum enum_mysql_show_type
|
||||
{
|
||||
SHOW_UNDEF, SHOW_BOOL,
|
||||
SHOW_INT,
|
||||
SHOW_LONG,
|
||||
SHOW_LONGLONG,
|
||||
SHOW_CHAR, SHOW_CHAR_PTR,
|
||||
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
|
||||
};
|
||||
enum enum_mysql_show_scope
|
||||
{
|
||||
SHOW_SCOPE_UNDEF,
|
||||
SHOW_SCOPE_GLOBAL
|
||||
};
|
||||
struct st_mysql_show_var
|
||||
{
|
||||
const char *name;
|
||||
char *value;
|
||||
enum enum_mysql_show_type type;
|
||||
enum enum_mysql_show_scope scope;
|
||||
};
|
||||
typedef int (*mysql_show_var_func)(void*, struct st_mysql_show_var*, char *);
|
||||
struct st_mysql_sys_var;
|
||||
struct st_mysql_value;
|
||||
typedef int (*mysql_var_check_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *save, struct st_mysql_value *value);
|
||||
typedef void (*mysql_var_update_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *var_ptr, const void *save);
|
||||
struct st_mysql_plugin
|
||||
{
|
||||
int type;
|
||||
void *info;
|
||||
const char *name;
|
||||
const char *author;
|
||||
const char *descr;
|
||||
int license;
|
||||
int (*init)(MYSQL_PLUGIN);
|
||||
int (*deinit)(MYSQL_PLUGIN);
|
||||
unsigned int version;
|
||||
struct st_mysql_show_var *status_vars;
|
||||
struct st_mysql_sys_var **system_vars;
|
||||
void * __reserved1;
|
||||
unsigned long flags;
|
||||
};
|
||||
struct st_mysql_daemon
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_information_schema
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_storage_engine
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct handlerton;
|
||||
struct Mysql_replication {
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_value
|
||||
{
|
||||
int (*value_type)(struct st_mysql_value *);
|
||||
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
|
||||
int (*val_real)(struct st_mysql_value *, double *realbuf);
|
||||
int (*val_int)(struct st_mysql_value *, long long *intbuf);
|
||||
int (*is_unsigned)(struct st_mysql_value *);
|
||||
};
|
||||
int thd_in_lock_tables(const void* thd);
|
||||
int thd_tablespace_op(const void* thd);
|
||||
long long thd_test_options(const void* thd, long long test_options);
|
||||
int thd_sql_command(const void* thd);
|
||||
const char *set_thd_proc_info(void* thd, const char *info,
|
||||
const char *calling_func,
|
||||
const char *calling_file,
|
||||
const unsigned int calling_line);
|
||||
void **thd_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_storage_lock_wait(void* thd, long long value);
|
||||
int thd_tx_isolation(const void* thd);
|
||||
int thd_tx_is_read_only(const void* thd);
|
||||
void* thd_tx_arbitrate(void* requestor, void* holder);
|
||||
int thd_tx_priority(const void* thd);
|
||||
int thd_tx_is_dd_trx(const void* thd);
|
||||
char *thd_security_context(void* thd, char *buffer, size_t length,
|
||||
size_t max_query_len);
|
||||
void thd_inc_row_count(void* thd);
|
||||
int thd_allow_batch(void* thd);
|
||||
void thd_mark_transaction_to_rollback(void* thd, int all);
|
||||
int mysql_tmpfile(const char *prefix);
|
||||
int thd_killed(const void* thd);
|
||||
void thd_set_kill_status(const void* thd);
|
||||
void thd_binlog_pos(const void* thd,
|
||||
const char **file_var,
|
||||
unsigned long long *pos_var);
|
||||
unsigned long thd_get_thread_id(const void* thd);
|
||||
void thd_get_xid(const void* thd, MYSQL_XID *xid);
|
||||
void mysql_query_cache_invalidate4(void* thd,
|
||||
const char *key, unsigned int key_length,
|
||||
int using_trx);
|
||||
void *thd_get_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_set_ha_data(void* thd, const struct handlerton *hton,
|
||||
const void *ha_data);
|
||||
enum enum_ftparser_mode
|
||||
{
|
||||
MYSQL_FTPARSER_SIMPLE_MODE= 0,
|
||||
MYSQL_FTPARSER_WITH_STOPWORDS= 1,
|
||||
MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2
|
||||
};
|
||||
enum enum_ft_token_type
|
||||
{
|
||||
FT_TOKEN_EOF= 0,
|
||||
FT_TOKEN_WORD= 1,
|
||||
FT_TOKEN_LEFT_PAREN= 2,
|
||||
FT_TOKEN_RIGHT_PAREN= 3,
|
||||
FT_TOKEN_STOPWORD= 4
|
||||
};
|
||||
typedef struct st_mysql_ftparser_boolean_info
|
||||
{
|
||||
enum enum_ft_token_type type;
|
||||
int yesno;
|
||||
int weight_adjust;
|
||||
char wasign;
|
||||
char trunc;
|
||||
int position;
|
||||
char prev;
|
||||
char *quot;
|
||||
} MYSQL_FTPARSER_BOOLEAN_INFO;
|
||||
typedef struct st_mysql_ftparser_param
|
||||
{
|
||||
int (*mysql_parse)(struct st_mysql_ftparser_param *,
|
||||
char *doc, int doc_len);
|
||||
int (*mysql_add_word)(struct st_mysql_ftparser_param *,
|
||||
char *word, int word_len,
|
||||
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info);
|
||||
void *ftparser_state;
|
||||
void *mysql_ftparam;
|
||||
const struct charset_info_st *cs;
|
||||
char *doc;
|
||||
int length;
|
||||
int flags;
|
||||
enum enum_ftparser_mode mode;
|
||||
} MYSQL_FTPARSER_PARAM;
|
||||
struct st_mysql_ftparser
|
||||
{
|
||||
int interface_version;
|
||||
int (*parse)(MYSQL_FTPARSER_PARAM *param);
|
||||
int (*init)(MYSQL_FTPARSER_PARAM *param);
|
||||
int (*deinit)(MYSQL_FTPARSER_PARAM *param);
|
||||
};
|
|
@ -0,0 +1,159 @@
|
|||
/* Copyright (c) 2013, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_PLUGIN_GROUP_REPLICATION_INCLUDED
|
||||
#define MYSQL_PLUGIN_GROUP_REPLICATION_INCLUDED
|
||||
|
||||
/* API for Group Peplication plugin. (MYSQL_GROUP_REPLICATION_PLUGIN) */
|
||||
|
||||
#include <mysql/plugin.h>
|
||||
#define MYSQL_GROUP_REPLICATION_INTERFACE_VERSION 0x0101
|
||||
|
||||
/*
|
||||
Callbacks for get_connection_status_info function.
|
||||
|
||||
context field can have NULL value, plugin will always pass it
|
||||
through all callbacks, independent of its value.
|
||||
Its value will not be used by plugin.
|
||||
|
||||
All callbacks are mandatory.
|
||||
*/
|
||||
typedef struct st_group_replication_connection_status_callbacks
|
||||
{
|
||||
void* const context;
|
||||
void (*set_channel_name)(void* const context, const char& value, size_t length);
|
||||
void (*set_group_name)(void* const context, const char& value, size_t length);
|
||||
void (*set_source_uuid)(void* const context, const char& value, size_t length);
|
||||
void (*set_service_state)(void* const context, bool state);
|
||||
} GROUP_REPLICATION_CONNECTION_STATUS_CALLBACKS;
|
||||
|
||||
/*
|
||||
Callbacks for get_group_members_info function.
|
||||
|
||||
context field can have NULL value, plugin will always pass it
|
||||
through all callbacks, independent of its value.
|
||||
Its value will not be used by plugin.
|
||||
|
||||
All callbacks are mandatory.
|
||||
*/
|
||||
typedef struct st_group_replication_group_members_callbacks
|
||||
{
|
||||
void* const context;
|
||||
void (*set_channel_name)(void* const context, const char& value, size_t length);
|
||||
void (*set_member_id)(void* const context, const char& value, size_t length);
|
||||
void (*set_member_host)(void* const context, const char& value, size_t length);
|
||||
void (*set_member_port)(void* const context, unsigned int value);
|
||||
void (*set_member_state)(void* const context, const char& value, size_t length);
|
||||
} GROUP_REPLICATION_GROUP_MEMBERS_CALLBACKS;
|
||||
|
||||
/*
|
||||
Callbacks for get_group_member_stats_info function.
|
||||
|
||||
context field can have NULL value, plugin will always pass it
|
||||
through all callbacks, independent of its value.
|
||||
Its value will not be used by plugin.
|
||||
|
||||
All callbacks are mandatory.
|
||||
*/
|
||||
typedef struct st_group_replication_member_stats_callbacks
|
||||
{
|
||||
void* const context;
|
||||
void (*set_channel_name)(void* const context, const char& value, size_t length);
|
||||
void (*set_view_id)(void* const context, const char& value, size_t length);
|
||||
void (*set_member_id)(void* const context, const char& value, size_t length);
|
||||
void (*set_transactions_committed)(void* const context, const char& value, size_t length);
|
||||
void (*set_last_conflict_free_transaction)(void* const context, const char& value, size_t length);
|
||||
void (*set_transactions_in_queue)(void* const context, unsigned long long int value);
|
||||
void (*set_transactions_certified)(void* const context, unsigned long long int value);
|
||||
void (*set_transactions_conflicts_detected)(void* const context, unsigned long long int value);
|
||||
void (*set_transactions_rows_in_validation)(void* const context, unsigned long long int value);
|
||||
} GROUP_REPLICATION_GROUP_MEMBER_STATS_CALLBACKS;
|
||||
|
||||
struct st_mysql_group_replication
|
||||
{
|
||||
int interface_version;
|
||||
|
||||
/*
|
||||
This function is used to start the group replication.
|
||||
*/
|
||||
int (*start)();
|
||||
/*
|
||||
This function is used to stop the group replication.
|
||||
*/
|
||||
int (*stop)();
|
||||
/*
|
||||
This function is used to get the current group replication running status.
|
||||
*/
|
||||
bool (*is_running)();
|
||||
/*
|
||||
This function initializes conflict checking module with info received
|
||||
from group on this member.
|
||||
|
||||
@param info View_change_log_event with conflict checking info.
|
||||
*/
|
||||
int (*set_retrieved_certification_info)(void* info);
|
||||
|
||||
/*
|
||||
This function is used to fetch information for group replication kernel stats.
|
||||
|
||||
@param callbacks The set of callbacks and its context used to set the
|
||||
information on caller.
|
||||
|
||||
@note The caller is responsible to free memory from the info structure and
|
||||
from all its fields.
|
||||
*/
|
||||
bool (*get_connection_status_info)
|
||||
(const GROUP_REPLICATION_CONNECTION_STATUS_CALLBACKS& callbacks);
|
||||
|
||||
/*
|
||||
This function is used to fetch information for group replication members.
|
||||
|
||||
@param callbacks The set of callbacks and its context used to set the
|
||||
information on caller.
|
||||
|
||||
@note The caller is responsible to free memory from the info structure and
|
||||
from all its fields.
|
||||
*/
|
||||
bool (*get_group_members_info)
|
||||
(unsigned int index,
|
||||
const GROUP_REPLICATION_GROUP_MEMBERS_CALLBACKS& callbacks);
|
||||
|
||||
/*
|
||||
This function is used to fetch information for group replication members statistics.
|
||||
|
||||
@param callbacks The set of callbacks and its context used to set the
|
||||
information on caller.
|
||||
|
||||
@note The caller is responsible to free memory from the info structure and
|
||||
from all its fields.
|
||||
*/
|
||||
bool (*get_group_member_stats_info)
|
||||
(const GROUP_REPLICATION_GROUP_MEMBER_STATS_CALLBACKS& callbacks);
|
||||
|
||||
/*
|
||||
Get number of group replication members.
|
||||
*/
|
||||
unsigned int (*get_members_number_info)();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,191 @@
|
|||
/* Copyright (c) 2016, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_PLUGIN_KEYRING_INCLUDED
|
||||
#define MYSQL_PLUGIN_KEYRING_INCLUDED
|
||||
|
||||
/**
|
||||
API for keyring plugin. (MYSQL_KEYRING_PLUGIN)
|
||||
*/
|
||||
|
||||
#include "plugin.h"
|
||||
#define MYSQL_KEYRING_INTERFACE_VERSION 0x0101
|
||||
|
||||
/**
|
||||
The descriptor structure for the plugin, that is referred from
|
||||
st_mysql_plugin.
|
||||
*/
|
||||
|
||||
struct st_mysql_keyring
|
||||
{
|
||||
int interface_version;
|
||||
/*!
|
||||
Add key to the keyring.
|
||||
|
||||
Obfuscates and adds the key to the keyring. The key is associated with
|
||||
key_id and user_id (unique key identifier).
|
||||
|
||||
@param[in] key_id id of the key to store
|
||||
@param[in] key_type type of the key to store
|
||||
@param[in] user_id id of the owner of the key
|
||||
@param[in] key the key itself to be stored. The memory of the key is
|
||||
copied by the keyring, thus the key itself can be freed
|
||||
after it was stored in the keyring.
|
||||
@param[in] key_len the length of the key to be stored
|
||||
|
||||
@return Operation status
|
||||
@retval 0 OK
|
||||
@retval 1 ERROR
|
||||
*/
|
||||
my_bool (*mysql_key_store)(const char *key_id, const char *key_type,
|
||||
const char* user_id, const void *key, size_t key_len);
|
||||
/*!
|
||||
Fetches key from the keyring.
|
||||
|
||||
De-obfuscates and retrieves key associated with key_id and user_id from the
|
||||
keyring.
|
||||
|
||||
@param[in] key_id id of the key to fetch
|
||||
@param[out] key_type type of the fetched key
|
||||
@param[in] user_id id of the owner of the key
|
||||
@param[out] key the fetched key itself. The memory for this key is
|
||||
allocated by the keyring and needs to be freed by the
|
||||
user when no longer needed. Prior to freeing the memory
|
||||
it needs to be obfuscated or zeroed.
|
||||
@param[out] key_len the length of the fetched key
|
||||
|
||||
@return Operation status
|
||||
@retval 0 OK
|
||||
@retval 1 ERROR
|
||||
*/
|
||||
my_bool (*mysql_key_fetch)(const char *key_id, char **key_type,
|
||||
const char *user_id, void **key, size_t *key_len);
|
||||
|
||||
/*!
|
||||
Removes key from the keyring.
|
||||
|
||||
Removes the key associated with key_id and user_id from the
|
||||
keyring.
|
||||
|
||||
@param[in] key_id id of the key to remove
|
||||
@param[in] user_id id of the owner of the key to remove
|
||||
|
||||
@return Operation status
|
||||
@retval 0 OK
|
||||
@retval 1 ERROR
|
||||
*/
|
||||
my_bool (*mysql_key_remove)(const char *key_id, const char *user_id);
|
||||
|
||||
/*!
|
||||
Generates and stores the key.
|
||||
|
||||
Generates a random key of length key_len, associates it with key_id, user_id
|
||||
and stores it in the keyring.
|
||||
|
||||
@param[in] key_id id of the key to generate
|
||||
@param[in] key_type type of the key to generate
|
||||
@param[in] user_id id of the owner of the generated key
|
||||
@param[in] key_len length of the key to generate
|
||||
|
||||
@return Operation status
|
||||
@retval 0 OK
|
||||
@retval 1 ERROR
|
||||
*/
|
||||
my_bool (*mysql_key_generate)(const char *key_id, const char *key_type,
|
||||
const char *user_id, size_t key_len);
|
||||
|
||||
/**
|
||||
Keys_iterator object refers to an iterator which is used to iterate
|
||||
on a list which refers to Key_metadata. Key_metadata hold information
|
||||
about individual keys keyd_id and user_id. Keys_iterator should be used
|
||||
in following sequence only.
|
||||
|
||||
void* iterator_ptr;
|
||||
char key_id[64]= { 0 };
|
||||
char user_id[64]= { 0 };
|
||||
|
||||
plugin_handle->mysql_key_iterator_init(&iterator_ptr);
|
||||
|
||||
if (iterator_ptr == NULL)
|
||||
report error;
|
||||
|
||||
while (!(plugin_handle->mysql_key_iterator_get_key(iterator_ptr,
|
||||
key_id, user_id)))
|
||||
{
|
||||
Fetch the keys.
|
||||
Perform operations on the fetched keys.
|
||||
..
|
||||
}
|
||||
plugin_handle->mysql_key_iterator_deinit(iterator_ptr);
|
||||
|
||||
init() method accepts a void pointer which is the made to point to
|
||||
Keys_iterator instance. Keys_iterator instance internal pointer points
|
||||
to Key_metadata list. This list holds information about all keys stored
|
||||
in the backed end data store of keyring plugin. After call to init()
|
||||
please check iterator_ptr.
|
||||
|
||||
get_key() method accepts the above iterator_ptr as IN param and then
|
||||
fills the passes in key_id and user_id with valid values. This can be
|
||||
used to fetch actual key information. Every call to this method will
|
||||
change internal pointers to advance to next position, so that the next
|
||||
call will fetch the next key.
|
||||
|
||||
deinit() method frees all internal pointers along with iterator_ptr.
|
||||
*/
|
||||
/**
|
||||
Initialize an iterator.
|
||||
|
||||
@param[out] key_iterator Iterator used to fetch individual keys
|
||||
from key_container.
|
||||
|
||||
@return VOID
|
||||
*/
|
||||
void (*mysql_key_iterator_init)(void** key_iterator);
|
||||
|
||||
/**
|
||||
Deinitialize an iterator.
|
||||
|
||||
@param[in] key_iterator Iterator used to fetch individual keys
|
||||
from key_container.
|
||||
|
||||
@return VOID
|
||||
*/
|
||||
void (*mysql_key_iterator_deinit)(void* key_iterator);
|
||||
|
||||
/**
|
||||
Get details of key. Every call to this service will change
|
||||
internal pointers to advance to next position, so that the next call
|
||||
will fetch the next key. In case iterator moves to the end, this service
|
||||
will return error.
|
||||
|
||||
@param[in] key_iterator Iterator used to fetch individual keys
|
||||
from key_container.
|
||||
@param[out] key_id id of the key
|
||||
@param[out] user_id id of the owner
|
||||
|
||||
@return Operation status
|
||||
@retval 0 OK
|
||||
@retval 1 ERROR
|
||||
*/
|
||||
bool (*mysql_key_iterator_get_key)(void* key_iterator, char *key_id, char *user_id);
|
||||
};
|
||||
#endif
|
|
@ -0,0 +1,127 @@
|
|||
#include "plugin.h"
|
||||
typedef void * MYSQL_PLUGIN;
|
||||
struct st_mysql_xid {
|
||||
long formatID;
|
||||
long gtrid_length;
|
||||
long bqual_length;
|
||||
char data[128];
|
||||
};
|
||||
typedef struct st_mysql_xid MYSQL_XID;
|
||||
enum enum_mysql_show_type
|
||||
{
|
||||
SHOW_UNDEF, SHOW_BOOL,
|
||||
SHOW_INT,
|
||||
SHOW_LONG,
|
||||
SHOW_LONGLONG,
|
||||
SHOW_CHAR, SHOW_CHAR_PTR,
|
||||
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
|
||||
};
|
||||
enum enum_mysql_show_scope
|
||||
{
|
||||
SHOW_SCOPE_UNDEF,
|
||||
SHOW_SCOPE_GLOBAL
|
||||
};
|
||||
struct st_mysql_show_var
|
||||
{
|
||||
const char *name;
|
||||
char *value;
|
||||
enum enum_mysql_show_type type;
|
||||
enum enum_mysql_show_scope scope;
|
||||
};
|
||||
typedef int (*mysql_show_var_func)(void*, struct st_mysql_show_var*, char *);
|
||||
struct st_mysql_sys_var;
|
||||
struct st_mysql_value;
|
||||
typedef int (*mysql_var_check_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *save, struct st_mysql_value *value);
|
||||
typedef void (*mysql_var_update_func)(void* thd,
|
||||
struct st_mysql_sys_var *var,
|
||||
void *var_ptr, const void *save);
|
||||
struct st_mysql_plugin
|
||||
{
|
||||
int type;
|
||||
void *info;
|
||||
const char *name;
|
||||
const char *author;
|
||||
const char *descr;
|
||||
int license;
|
||||
int (*init)(MYSQL_PLUGIN);
|
||||
int (*deinit)(MYSQL_PLUGIN);
|
||||
unsigned int version;
|
||||
struct st_mysql_show_var *status_vars;
|
||||
struct st_mysql_sys_var **system_vars;
|
||||
void * __reserved1;
|
||||
unsigned long flags;
|
||||
};
|
||||
struct st_mysql_daemon
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_information_schema
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_storage_engine
|
||||
{
|
||||
int interface_version;
|
||||
};
|
||||
struct handlerton;
|
||||
struct Mysql_replication {
|
||||
int interface_version;
|
||||
};
|
||||
struct st_mysql_value
|
||||
{
|
||||
int (*value_type)(struct st_mysql_value *);
|
||||
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
|
||||
int (*val_real)(struct st_mysql_value *, double *realbuf);
|
||||
int (*val_int)(struct st_mysql_value *, long long *intbuf);
|
||||
int (*is_unsigned)(struct st_mysql_value *);
|
||||
};
|
||||
int thd_in_lock_tables(const void* thd);
|
||||
int thd_tablespace_op(const void* thd);
|
||||
long long thd_test_options(const void* thd, long long test_options);
|
||||
int thd_sql_command(const void* thd);
|
||||
const char *set_thd_proc_info(void* thd, const char *info,
|
||||
const char *calling_func,
|
||||
const char *calling_file,
|
||||
const unsigned int calling_line);
|
||||
void **thd_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_storage_lock_wait(void* thd, long long value);
|
||||
int thd_tx_isolation(const void* thd);
|
||||
int thd_tx_is_read_only(const void* thd);
|
||||
void* thd_tx_arbitrate(void* requestor, void* holder);
|
||||
int thd_tx_priority(const void* thd);
|
||||
int thd_tx_is_dd_trx(const void* thd);
|
||||
char *thd_security_context(void* thd, char *buffer, size_t length,
|
||||
size_t max_query_len);
|
||||
void thd_inc_row_count(void* thd);
|
||||
int thd_allow_batch(void* thd);
|
||||
void thd_mark_transaction_to_rollback(void* thd, int all);
|
||||
int mysql_tmpfile(const char *prefix);
|
||||
int thd_killed(const void* thd);
|
||||
void thd_set_kill_status(const void* thd);
|
||||
void thd_binlog_pos(const void* thd,
|
||||
const char **file_var,
|
||||
unsigned long long *pos_var);
|
||||
unsigned long thd_get_thread_id(const void* thd);
|
||||
void thd_get_xid(const void* thd, MYSQL_XID *xid);
|
||||
void mysql_query_cache_invalidate4(void* thd,
|
||||
const char *key, unsigned int key_length,
|
||||
int using_trx);
|
||||
void *thd_get_ha_data(const void* thd, const struct handlerton *hton);
|
||||
void thd_set_ha_data(void* thd, const struct handlerton *hton,
|
||||
const void *ha_data);
|
||||
struct st_mysql_keyring
|
||||
{
|
||||
int interface_version;
|
||||
my_bool (*mysql_key_store)(const char *key_id, const char *key_type,
|
||||
const char* user_id, const void *key, size_t key_len);
|
||||
my_bool (*mysql_key_fetch)(const char *key_id, char **key_type,
|
||||
const char *user_id, void **key, size_t *key_len);
|
||||
my_bool (*mysql_key_remove)(const char *key_id, const char *user_id);
|
||||
my_bool (*mysql_key_generate)(const char *key_id, const char *key_type,
|
||||
const char *user_id, size_t key_len);
|
||||
void (*mysql_key_iterator_init)(void** key_iterator);
|
||||
void (*mysql_key_iterator_deinit)(void* key_iterator);
|
||||
bool (*mysql_key_iterator_get_key)(void* key_iterator, char *key_id, char *user_id);
|
||||
};
|
|
@ -0,0 +1,356 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef PLUGIN_TRACE_INCLUDED
|
||||
#define PLUGIN_TRACE_INCLUDED
|
||||
/**
|
||||
@file
|
||||
|
||||
========================================================================
|
||||
Declarations for client-side plugins of type MYSQL_CLIENT_TRACE_PLUGIN
|
||||
========================================================================
|
||||
|
||||
See libmysql/mysql_trace.c for a brief description of the client-side
|
||||
protocol tracing infrastructure.
|
||||
*/
|
||||
|
||||
|
||||
#include <mysql/client_plugin.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
Lists of protocol stages and trace events
|
||||
=========================================
|
||||
|
||||
These lists are defined with PROTOCOL_STAGE_LIST() and TRACE_EVENT_LIST(),
|
||||
respectively. Macros accept a disposition name as an argument.
|
||||
|
||||
For example, to process list of protocol stages using disposition "foo",
|
||||
define protocol_stage_foo(Stage) macro and then put
|
||||
|
||||
PROTOCOL_STAGE_LIST(foo)
|
||||
|
||||
in your code. This will expand to sequence of protocol_stage_foo(X)
|
||||
macros where X ranges over the list of protocol stages, and these macros
|
||||
should generate the actual code. See below how this technique is used
|
||||
to generate protocol_stage and trace_events enums.
|
||||
*/
|
||||
|
||||
/**
|
||||
Protocol stages
|
||||
---------------
|
||||
|
||||
A client following the MySQL protocol goes through several stages of it. Each
|
||||
stage determines what packets can be expected from the server or can be send
|
||||
by the client.
|
||||
|
||||
Upon receiving each trace event, trace plugin will be notified of the current
|
||||
protocol stage so that it can correctly interpret the event.
|
||||
|
||||
These are the possible protocol stages and the transitions between them.
|
||||
|
||||
.. digraph:: protocol_stages
|
||||
|
||||
CONNECTING -> WAIT_FOR_INIT_PACKET;
|
||||
CONNECTING -> DISCONNECTED [ label = "failed connection" ];
|
||||
|
||||
WAIT_FOR_INIT_PACKET -> AUTHENTICATE;
|
||||
WAIT_FOR_INIT_PACKET -> SSL_NEGOTIATION -> AUTHENTICATE;
|
||||
|
||||
AUTHENTICATE -> READY_FOR_COMMAND [ label = "accepted" ];
|
||||
AUTHENTICATE -> DISCONNECTED [ label = "rejected" ];
|
||||
|
||||
READY_FOR_COMMAND -> DISCONNECTED [ label = "COM_QUIT" ];
|
||||
READY_FOR_COMMAND -> AUTHENTICATE [ label="after change user" ];
|
||||
READY_FOR_COMMAND -> WAIT_FOR_PACKET
|
||||
[ label="wait for a single packet after, e.g., COM_STATISTICS" ];
|
||||
READY_FOR_COMMAND -> WAIT_FOR_RESULT;
|
||||
READY_FOR_COMMAND -> WAIT_FOR_PS_DESCRIPTION
|
||||
[ label="after prepare command" ];
|
||||
|
||||
WAIT_FOR_PACKET -> READY_FOR_COMAND;
|
||||
|
||||
WAIT_FOR_RESULT -> READY_FOR_COMMAND [ label="simple reply" ];
|
||||
WAIT_FOR_RESULT -> WAIT_FOR_FIELD_DEF;
|
||||
WAIT_FOR_RESULT -> FILE_REQUEST;
|
||||
|
||||
WAIT_FOR_FIELD_DEF -> WAIT_FOR_ROW [ label="in a resultset" ];
|
||||
WAIT_FOR_FIELD_DEF -> READY_FOR_COMMAND
|
||||
[ label="after describe table or prepare command" ];
|
||||
|
||||
WAIT_FOR_ROW -> READY_FOR_COMMAND;
|
||||
WAIT_FOR_ROW -> WAIT_FOR_RESULT [ label="multi-resultset" ];
|
||||
|
||||
WAIT_FOR_PS_DESCRIPTION -> WAIT_FOR_PARAM_DEF;
|
||||
WAIT_FOR_PS_DESCRIPTION -> READY_FOR_COMMAND
|
||||
[ label="no params and result" ];
|
||||
WAIT_FOR_PS_DESCRIPTION -> WAIT_FOR_FIELD_DEF [ label="no params" ];
|
||||
|
||||
WAIT_FOR_PARAM_DEF -> WAIT_FOR_FIELD_DEF;
|
||||
WAIT_FOR_PARAM_DEF -> READY_FOR_COMMAND [ label="no result" ];
|
||||
|
||||
FILE_REQUEST -> WAIT_FOR_RESULT [label="when whole file sent"];
|
||||
*/
|
||||
|
||||
#define PROTOCOL_STAGE_LIST(X) \
|
||||
protocol_stage_ ## X(CONNECTING) \
|
||||
protocol_stage_ ## X(WAIT_FOR_INIT_PACKET) \
|
||||
protocol_stage_ ## X(AUTHENTICATE) \
|
||||
protocol_stage_ ## X(SSL_NEGOTIATION) \
|
||||
protocol_stage_ ## X(READY_FOR_COMMAND) \
|
||||
protocol_stage_ ## X(WAIT_FOR_PACKET) \
|
||||
protocol_stage_ ## X(WAIT_FOR_RESULT) \
|
||||
protocol_stage_ ## X(WAIT_FOR_FIELD_DEF) \
|
||||
protocol_stage_ ## X(WAIT_FOR_ROW) \
|
||||
protocol_stage_ ## X(FILE_REQUEST) \
|
||||
protocol_stage_ ## X(WAIT_FOR_PS_DESCRIPTION) \
|
||||
protocol_stage_ ## X(WAIT_FOR_PARAM_DEF) \
|
||||
protocol_stage_ ## X(DISCONNECTED)
|
||||
|
||||
/**
|
||||
Trace events
|
||||
------------
|
||||
|
||||
The following events are generated during the various stages of the
|
||||
client-server conversation.
|
||||
|
||||
---------------------- -----------------------------------------------------
|
||||
Connection events
|
||||
---------------------- -----------------------------------------------------
|
||||
CONNECTING Client is connecting to the server.
|
||||
CONNECTED Physical connection has been established.
|
||||
DISCONNECTED Connection with server was broken.
|
||||
---------------------- -----------------------------------------------------
|
||||
SSL events
|
||||
---------------------- -----------------------------------------------------
|
||||
SEND_SSL_REQUEST Client is sending SSL connection request.
|
||||
SSL_CONNECT Client is initiating SSL handshake.
|
||||
SSL_CONNECTED SSL connection has been established.
|
||||
---------------------- -----------------------------------------------------
|
||||
Authentication events
|
||||
---------------------- -----------------------------------------------------
|
||||
CHALLENGE_RECEIVED Client received authentication challenge.
|
||||
AUTH_PLUGIN Client selects an authentication plugin to be used
|
||||
in the following authentication exchange.
|
||||
SEND_AUTH_RESPONSE Client sends response to the authentication
|
||||
challenge.
|
||||
SEND_AUTH_DATA Client sends extra authentication data packet.
|
||||
AUTHENTICATED Server has accepted connection.
|
||||
---------------------- -----------------------------------------------------
|
||||
Command phase events
|
||||
---------------------- -----------------------------------------------------
|
||||
SEND_COMMAND Client is sending a command to the server.
|
||||
SEND_FILE Client is sending local file contents to the server.
|
||||
---------------------- -----------------------------------------------------
|
||||
General events
|
||||
---------------------- -----------------------------------------------------
|
||||
READ_PACKET Client starts waiting for a packet from server.
|
||||
PACKET_RECEIVED A packet from server has been received.
|
||||
PACKET_SENT After successful sending of a packet to the server.
|
||||
ERROR Client detected an error.
|
||||
---------------------- -----------------------------------------------------
|
||||
*/
|
||||
|
||||
#define TRACE_EVENT_LIST(X) \
|
||||
trace_event_ ## X(ERROR) \
|
||||
trace_event_ ## X(CONNECTING) \
|
||||
trace_event_ ## X(CONNECTED) \
|
||||
trace_event_ ## X(DISCONNECTED) \
|
||||
trace_event_ ## X(SEND_SSL_REQUEST) \
|
||||
trace_event_ ## X(SSL_CONNECT) \
|
||||
trace_event_ ## X(SSL_CONNECTED) \
|
||||
trace_event_ ## X(INIT_PACKET_RECEIVED) \
|
||||
trace_event_ ## X(AUTH_PLUGIN) \
|
||||
trace_event_ ## X(SEND_AUTH_RESPONSE) \
|
||||
trace_event_ ## X(SEND_AUTH_DATA) \
|
||||
trace_event_ ## X(AUTHENTICATED) \
|
||||
trace_event_ ## X(SEND_COMMAND) \
|
||||
trace_event_ ## X(SEND_FILE) \
|
||||
trace_event_ ## X(READ_PACKET) \
|
||||
trace_event_ ## X(PACKET_RECEIVED) \
|
||||
trace_event_ ## X(PACKET_SENT)
|
||||
|
||||
/**
|
||||
Some trace events have additional arguments. These are stored in
|
||||
st_trace_event_args structure. Various events store their arguments in the
|
||||
structure as follows. Unused members are set to 0/NULL.
|
||||
|
||||
AUTH_PLUGIN
|
||||
------------- ----------------------------------
|
||||
plugin_name the name of the plugin
|
||||
------------- ----------------------------------
|
||||
|
||||
SEND_COMMAND
|
||||
------------- ----------------------------------
|
||||
cmd the command code
|
||||
hdr pointer to command packet header
|
||||
hdr_len length of the header
|
||||
pkt pointer to command arguments
|
||||
pkt_len length of arguments
|
||||
------------- ----------------------------------
|
||||
|
||||
Other SEND_* and *_RECEIVED events
|
||||
------------- ----------------------------------
|
||||
pkt the data sent or received
|
||||
pkt_len length of the data
|
||||
------------- ----------------------------------
|
||||
|
||||
PACKET_SENT
|
||||
------------- ----------------------------------
|
||||
pkt_len number of bytes sent
|
||||
------------- ----------------------------------
|
||||
*/
|
||||
|
||||
struct st_trace_event_args
|
||||
{
|
||||
const char *plugin_name;
|
||||
int cmd;
|
||||
const unsigned char *hdr;
|
||||
size_t hdr_len;
|
||||
const unsigned char *pkt;
|
||||
size_t pkt_len;
|
||||
};
|
||||
|
||||
|
||||
/* Definitions of protocol_stage and trace_event enums. */
|
||||
|
||||
#define protocol_stage_enum(X) PROTOCOL_STAGE_ ## X,
|
||||
|
||||
enum protocol_stage {
|
||||
PROTOCOL_STAGE_LIST(enum)
|
||||
PROTOCOL_STAGE_LAST
|
||||
};
|
||||
|
||||
#define trace_event_enum(X) TRACE_EVENT_ ## X,
|
||||
|
||||
enum trace_event {
|
||||
TRACE_EVENT_LIST(enum)
|
||||
TRACE_EVENT_LAST
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
Trace plugin methods
|
||||
====================
|
||||
*/
|
||||
|
||||
struct st_mysql_client_plugin_TRACE;
|
||||
struct st_mysql;
|
||||
|
||||
/**
|
||||
Trace plugin tracing_start() method.
|
||||
|
||||
Called when tracing with this plugin starts on a connection. A trace
|
||||
plugin might want to maintain per-connection information. It can
|
||||
return a pointer to memory area holding such information. It will be
|
||||
stored in a connection handle and passed to other plugin methods.
|
||||
|
||||
@param self pointer to the plugin instance
|
||||
@param connection_handle
|
||||
@param stage protocol stage in which tracing has started - currently
|
||||
it is always CONNECTING stage.
|
||||
|
||||
@return A pointer to plugin-specific, per-connection data if any.
|
||||
*/
|
||||
|
||||
typedef
|
||||
void* (tracing_start_callback)(struct st_mysql_client_plugin_TRACE *self,
|
||||
struct st_mysql *connection_handle,
|
||||
enum protocol_stage stage);
|
||||
|
||||
/**
|
||||
Trace plugin tracing_stop() method.
|
||||
|
||||
Called when tracing of the connection has ended. If a plugin
|
||||
allocated any per-connection resources, it should de-allocate them
|
||||
here.
|
||||
|
||||
@param self pointer to the plugin instance
|
||||
@param connection_handle
|
||||
@param plugin_data pointer to plugin's per-connection data.
|
||||
*/
|
||||
|
||||
typedef
|
||||
void (tracing_stop_callback)(struct st_mysql_client_plugin_TRACE *self,
|
||||
struct st_mysql *connection_handle,
|
||||
void *plugin_data);
|
||||
|
||||
/**
|
||||
Trace plugin trace_event() method.
|
||||
|
||||
Called when a trace event occurs. Plugin can decide to stop tracing
|
||||
this connection by returning non-zero value.
|
||||
|
||||
@param self pointer to the plugin instance
|
||||
@param plugin_data pointer to plugin's per-connection data
|
||||
@param connection_handle
|
||||
@param stage current protocol stage
|
||||
@param event the trace event
|
||||
@param args trace event arguments
|
||||
|
||||
@return Non-zero if tracing of the connection should end here.
|
||||
*/
|
||||
|
||||
typedef
|
||||
int (trace_event_handler)(struct st_mysql_client_plugin_TRACE *self,
|
||||
void *plugin_data,
|
||||
struct st_mysql *connection_handle,
|
||||
enum protocol_stage stage,
|
||||
enum trace_event event,
|
||||
struct st_trace_event_args args);
|
||||
|
||||
|
||||
struct st_mysql_client_plugin_TRACE
|
||||
{
|
||||
MYSQL_CLIENT_PLUGIN_HEADER
|
||||
tracing_start_callback *tracing_start;
|
||||
tracing_stop_callback *tracing_stop;
|
||||
trace_event_handler *trace_event;
|
||||
};
|
||||
|
||||
/**
|
||||
The global trace_plugin pointer. If it is not NULL, it points at a
|
||||
loaded trace plugin which should be used to trace all connections made
|
||||
to the server.
|
||||
*/
|
||||
extern
|
||||
struct st_mysql_client_plugin_TRACE *trace_plugin;
|
||||
|
||||
#ifndef NDEBUG
|
||||
|
||||
/*
|
||||
Functions for getting names of trace events and protocol
|
||||
stages for debugging purposes.
|
||||
*/
|
||||
const char* protocol_stage_name(enum protocol_stage stage);
|
||||
const char* trace_event_name(enum trace_event ev);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,53 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_PLUGIN_VALIDATE_PASSWORD_INCLUDED
|
||||
#define MYSQL_PLUGIN_VALIDATE_PASSWORD_INCLUDED
|
||||
|
||||
/* API for validate_password plugin. (MYSQL_VALIDATE_PASSWORD_PLUGIN) */
|
||||
|
||||
#include <mysql/plugin.h>
|
||||
#define MYSQL_VALIDATE_PASSWORD_INTERFACE_VERSION 0x0100
|
||||
|
||||
/*
|
||||
The descriptor structure for the plugin, that is referred from
|
||||
st_mysql_plugin.
|
||||
*/
|
||||
|
||||
typedef void* mysql_string_handle;
|
||||
|
||||
struct st_mysql_validate_password
|
||||
{
|
||||
int interface_version;
|
||||
/*
|
||||
This function retuns TRUE for passwords which satisfy the password
|
||||
policy (as choosen by plugin variable) and FALSE for all other
|
||||
password
|
||||
*/
|
||||
int (*validate_password)(mysql_string_handle password);
|
||||
/*
|
||||
This function returns the password strength (0-100) depending
|
||||
upon the policies
|
||||
*/
|
||||
int (*get_password_strength)(mysql_string_handle password);
|
||||
};
|
||||
#endif
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,103 @@
|
|||
/* Copyright (c) 2011, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_IDLE_H
|
||||
#define MYSQL_IDLE_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_idle.h
|
||||
Instrumentation helpers for idle waits.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_IDLE_CALL
|
||||
#define PSI_IDLE_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Idle_instrumentation Idle Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def MYSQL_START_IDLE_WAIT
|
||||
Instrumentation helper for table io_waits.
|
||||
This instrumentation marks the start of a wait event.
|
||||
@param LOCKER the locker
|
||||
@param STATE the locker state
|
||||
@sa MYSQL_END_IDLE_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_IDLE_INTERFACE
|
||||
#define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
|
||||
LOCKER= inline_mysql_start_idle_wait(STATE, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_END_IDLE_WAIT
|
||||
Instrumentation helper for idle waits.
|
||||
This instrumentation marks the end of a wait event.
|
||||
@param LOCKER the locker
|
||||
@sa MYSQL_START_IDLE_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_IDLE_INTERFACE
|
||||
#define MYSQL_END_IDLE_WAIT(LOCKER) \
|
||||
inline_mysql_end_idle_wait(LOCKER)
|
||||
#else
|
||||
#define MYSQL_END_IDLE_WAIT(LOCKER) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_IDLE_INTERFACE
|
||||
/**
|
||||
Instrumentation calls for MYSQL_START_IDLE_WAIT.
|
||||
@sa MYSQL_END_IDLE_WAIT.
|
||||
*/
|
||||
static inline struct PSI_idle_locker *
|
||||
inline_mysql_start_idle_wait(PSI_idle_locker_state *state,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
struct PSI_idle_locker *locker;
|
||||
locker= PSI_IDLE_CALL(start_idle_wait)(state, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
|
||||
/**
|
||||
Instrumentation calls for MYSQL_END_IDLE_WAIT.
|
||||
@sa MYSQL_START_IDLE_WAIT.
|
||||
*/
|
||||
static inline void
|
||||
inline_mysql_end_idle_wait(struct PSI_idle_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_IDLE_CALL(end_idle_wait)(locker);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Idle_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_MDL_H
|
||||
#define MYSQL_MDL_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_mdl.h
|
||||
Instrumentation helpers for metadata locks.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_METADATA_CALL
|
||||
#define PSI_METADATA_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Thread_instrumentation Metadata Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_mdl_create(K, M, A)
|
||||
Instrumented metadata lock creation.
|
||||
@param I Metadata lock identity
|
||||
@param K Metadata key
|
||||
@param T Metadata lock type
|
||||
@param D Metadata lock duration
|
||||
@param S Metadata lock status
|
||||
@param F request source file
|
||||
@param L request source line
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
#define mysql_mdl_create(I, K, T, D, S, F, L) \
|
||||
inline_mysql_mdl_create(I, K, T, D, S, F, L)
|
||||
#else
|
||||
#define mysql_mdl_create(I, K, T, D, S, F, L) NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
#define mysql_mdl_set_status(L, S) \
|
||||
inline_mysql_mdl_set_status(L, S)
|
||||
#else
|
||||
#define mysql_mdl_set_status(L, S) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
@def mysql_mdl_destroy(M)
|
||||
Instrumented metadata lock destruction.
|
||||
@param M Metadata lock
|
||||
*/
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
#define mysql_mdl_destroy(M) \
|
||||
inline_mysql_mdl_destroy(M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mdl_destroy(M) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
|
||||
static inline PSI_metadata_lock *
|
||||
inline_mysql_mdl_create(void *identity,
|
||||
const MDL_key *mdl_key,
|
||||
enum_mdl_type mdl_type,
|
||||
enum_mdl_duration mdl_duration,
|
||||
MDL_ticket::enum_psi_status mdl_status,
|
||||
const char *src_file, uint src_line)
|
||||
{
|
||||
PSI_metadata_lock *result;
|
||||
|
||||
/* static_cast: Fit a round C++ enum peg into a square C int hole ... */
|
||||
result= PSI_METADATA_CALL(create_metadata_lock)
|
||||
(identity,
|
||||
mdl_key,
|
||||
static_cast<opaque_mdl_type> (mdl_type),
|
||||
static_cast<opaque_mdl_duration> (mdl_duration),
|
||||
static_cast<opaque_mdl_status> (mdl_status),
|
||||
src_file, src_line);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void inline_mysql_mdl_set_status(
|
||||
PSI_metadata_lock *psi,
|
||||
MDL_ticket::enum_psi_status mdl_status)
|
||||
{
|
||||
if (psi != NULL)
|
||||
PSI_METADATA_CALL(set_metadata_lock_status)(psi, mdl_status);
|
||||
}
|
||||
|
||||
static inline void inline_mysql_mdl_destroy(
|
||||
PSI_metadata_lock *psi,
|
||||
const char *src_file, uint src_line)
|
||||
{
|
||||
if (psi != NULL)
|
||||
PSI_METADATA_CALL(destroy_metadata_lock)(psi);
|
||||
}
|
||||
#endif /* HAVE_PSI_METADATA_INTERFACE */
|
||||
|
||||
/** @} (end of group Metadata_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_MEMORY_H
|
||||
#define MYSQL_MEMORY_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_memory.h
|
||||
Instrumentation helpers for memory allocation.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_MEMORY_CALL
|
||||
#define PSI_MEMORY_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Memory_instrumentation Memory Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_memory_register(P1, P2, P3)
|
||||
Memory registration.
|
||||
*/
|
||||
#define mysql_memory_register(P1, P2, P3) \
|
||||
inline_mysql_memory_register(P1, P2, P3)
|
||||
|
||||
static inline void inline_mysql_memory_register(
|
||||
#ifdef HAVE_PSI_MEMORY_INTERFACE
|
||||
const char *category,
|
||||
PSI_memory_info *info,
|
||||
int count)
|
||||
#else
|
||||
const char *category MY_ATTRIBUTE((unused)),
|
||||
void *info MY_ATTRIBUTE((unused)),
|
||||
int count MY_ATTRIBUTE((unused)))
|
||||
#endif
|
||||
{
|
||||
#ifdef HAVE_PSI_MEMORY_INTERFACE
|
||||
PSI_MEMORY_CALL(register_memory)(category, info, count);
|
||||
#endif
|
||||
}
|
||||
|
||||
/** @} (end of group Memory_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
/* Copyright (c) 2014, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_PS_H
|
||||
#define MYSQL_PS_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_ps.h
|
||||
Instrumentation helpers for prepared statements.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_PS_CALL
|
||||
#define PSI_PS_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_PS_INTERFACE
|
||||
#define MYSQL_CREATE_PS(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH, SQLTEXT, SQLTEXT_LENGTH) \
|
||||
inline_mysql_create_prepared_stmt(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH, SQLTEXT, SQLTEXT_LENGTH)
|
||||
#define MYSQL_EXECUTE_PS(LOCKER, PREPARED_STMT) \
|
||||
inline_mysql_execute_prepared_stmt(LOCKER, PREPARED_STMT)
|
||||
#define MYSQL_DESTROY_PS(PREPARED_STMT) \
|
||||
inline_mysql_destroy_prepared_stmt(PREPARED_STMT)
|
||||
#define MYSQL_REPREPARE_PS(PREPARED_STMT) \
|
||||
inline_mysql_reprepare_prepared_stmt(PREPARED_STMT)
|
||||
#define MYSQL_SET_PS_TEXT(PREPARED_STMT, SQLTEXT, SQLTEXT_LENGTH) \
|
||||
inline_mysql_set_prepared_stmt_text(PREPARED_STMT, SQLTEXT, SQLTEXT_LENGTH)
|
||||
#else
|
||||
#define MYSQL_CREATE_PS(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH, SQLTEXT, SQLTEXT_LENGTH) \
|
||||
NULL
|
||||
#define MYSQL_EXECUTE_PS(LOCKER, PREPARED_STMT) \
|
||||
do {} while (0)
|
||||
#define MYSQL_DESTROY_PS(PREPARED_STMT) \
|
||||
do {} while (0)
|
||||
#define MYSQL_REPREPARE_PS(PREPARED_STMT) \
|
||||
do {} while (0)
|
||||
#define MYSQL_SET_PS_TEXT(PREPARED_STMT, SQLTEXT, SQLTEXT_LENGTH) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_PS_INTERFACE
|
||||
static inline struct PSI_prepared_stmt*
|
||||
inline_mysql_create_prepared_stmt(void *identity, uint stmt_id,
|
||||
PSI_statement_locker *locker,
|
||||
const char *stmt_name, size_t stmt_name_length,
|
||||
const char *sqltext, size_t sqltext_length)
|
||||
{
|
||||
if (locker == NULL)
|
||||
return NULL;
|
||||
return PSI_PS_CALL(create_prepared_stmt)(identity, stmt_id,
|
||||
locker,
|
||||
stmt_name, stmt_name_length,
|
||||
sqltext, sqltext_length);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_execute_prepared_stmt(PSI_statement_locker *locker,
|
||||
PSI_prepared_stmt* prepared_stmt)
|
||||
{
|
||||
if (prepared_stmt != NULL && locker != NULL)
|
||||
PSI_PS_CALL(execute_prepared_stmt)(locker, prepared_stmt);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_destroy_prepared_stmt(PSI_prepared_stmt *prepared_stmt)
|
||||
{
|
||||
if (prepared_stmt != NULL)
|
||||
PSI_PS_CALL(destroy_prepared_stmt)(prepared_stmt);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_reprepare_prepared_stmt(PSI_prepared_stmt *prepared_stmt)
|
||||
{
|
||||
if (prepared_stmt != NULL)
|
||||
PSI_PS_CALL(reprepare_prepared_stmt)(prepared_stmt);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_prepared_stmt_text(PSI_prepared_stmt *prepared_stmt,
|
||||
const char *text,
|
||||
uint text_len)
|
||||
{
|
||||
if (prepared_stmt != NULL)
|
||||
{
|
||||
PSI_PS_CALL(set_prepared_stmt_text)(prepared_stmt, text, text_len);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,104 @@
|
|||
/* Copyright (c) 2013, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SP_H
|
||||
#define MYSQL_SP_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_sp.h
|
||||
Instrumentation helpers for stored programs.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_SP_CALL
|
||||
#define PSI_SP_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_START_SP(STATE, SP_SHARE) \
|
||||
inline_mysql_start_sp(STATE, SP_SHARE)
|
||||
#else
|
||||
#define MYSQL_START_SP(STATE, SP_SHARE) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_END_SP(LOCKER) \
|
||||
inline_mysql_end_sp(LOCKER)
|
||||
#else
|
||||
#define MYSQL_END_SP(LOCKER) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_DROP_SP(OT, SN, SNL, ON, ONL) \
|
||||
inline_mysql_drop_sp(OT, SN, SNL, ON, ONL)
|
||||
#else
|
||||
#define MYSQL_DROP_SP(OT, SN, SNL, ON, ONL) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_GET_SP_SHARE(OT, SN, SNL, ON, ONL) \
|
||||
inline_mysql_get_sp_share(OT, SN, SNL, ON, ONL)
|
||||
#else
|
||||
#define MYSQL_GET_SP_SHARE(OT, SN, SNL, ON, ONL) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
static inline struct PSI_sp_locker*
|
||||
inline_mysql_start_sp(PSI_sp_locker_state *state, PSI_sp_share *sp_share)
|
||||
{
|
||||
return PSI_SP_CALL(start_sp)(state, sp_share);
|
||||
}
|
||||
|
||||
static inline void inline_mysql_end_sp(PSI_sp_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_SP_CALL(end_sp)(locker);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_drop_sp(uint sp_type,
|
||||
const char* schema_name, uint shcema_name_length,
|
||||
const char* object_name, uint object_name_length)
|
||||
{
|
||||
PSI_SP_CALL(drop_sp)(sp_type,
|
||||
schema_name, shcema_name_length,
|
||||
object_name, object_name_length);
|
||||
}
|
||||
|
||||
static inline PSI_sp_share*
|
||||
inline_mysql_get_sp_share(uint sp_type,
|
||||
const char* schema_name, uint shcema_name_length,
|
||||
const char* object_name, uint object_name_length)
|
||||
{
|
||||
return PSI_SP_CALL(get_sp_share)(sp_type,
|
||||
schema_name, shcema_name_length,
|
||||
object_name, object_name_length);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,205 @@
|
|||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_STAGE_H
|
||||
#define MYSQL_STAGE_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_stage.h
|
||||
Instrumentation helpers for stages.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_STAGE_CALL
|
||||
#define PSI_STAGE_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Stage_instrumentation Stage Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_stage_register(P1, P2, P3)
|
||||
Stage registration.
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_register(P1, P2, P3) \
|
||||
inline_mysql_stage_register(P1, P2, P3)
|
||||
#else
|
||||
#define mysql_stage_register(P1, P2, P3) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_SET_STAGE
|
||||
Set the current stage.
|
||||
Use this API when the file and line
|
||||
is passed from the caller.
|
||||
@param K the stage key
|
||||
@param F the source file name
|
||||
@param L the source file line
|
||||
@return the current stage progress
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define MYSQL_SET_STAGE(K, F, L) \
|
||||
inline_mysql_set_stage(K, F, L)
|
||||
#else
|
||||
#define MYSQL_SET_STAGE(K, F, L) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_set_stage
|
||||
Set the current stage.
|
||||
@param K the stage key
|
||||
@return the current stage progress
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_set_stage(K) \
|
||||
inline_mysql_set_stage(K, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_set_stage(K) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_end_stage
|
||||
End the last stage
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_end_stage \
|
||||
inline_mysql_end_stage
|
||||
#else
|
||||
#define mysql_end_stage \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void inline_mysql_stage_register(
|
||||
const char *category, PSI_stage_info **info, int count)
|
||||
{
|
||||
PSI_STAGE_CALL(register_stage)(category, info, count);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline PSI_stage_progress*
|
||||
inline_mysql_set_stage(PSI_stage_key key,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
return PSI_STAGE_CALL(start_stage)(key, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_end_stage()
|
||||
{
|
||||
PSI_STAGE_CALL(end_stage)();
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_set_work_completed(P1, P2) \
|
||||
inline_mysql_stage_set_work_completed(P1, P2)
|
||||
|
||||
#define mysql_stage_get_work_completed(P1) \
|
||||
inline_mysql_stage_get_work_completed(P1)
|
||||
#else
|
||||
#define mysql_stage_set_work_completed(P1, P2) \
|
||||
do {} while (0)
|
||||
|
||||
#define mysql_stage_get_work_completed(P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_inc_work_completed(P1, P2) \
|
||||
inline_mysql_stage_inc_work_completed(P1, P2)
|
||||
#else
|
||||
#define mysql_stage_inc_work_completed(P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_set_work_estimated(P1, P2) \
|
||||
inline_mysql_stage_set_work_estimated(P1, P2)
|
||||
|
||||
#define mysql_stage_get_work_estimated(P1) \
|
||||
inline_mysql_stage_get_work_estimated(P1)
|
||||
#else
|
||||
#define mysql_stage_set_work_estimated(P1, P2) \
|
||||
do {} while (0)
|
||||
|
||||
#define mysql_stage_get_work_estimated(P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_stage_set_work_completed(PSI_stage_progress *progress,
|
||||
ulonglong val)
|
||||
{
|
||||
if (progress != NULL)
|
||||
progress->m_work_completed= val;
|
||||
}
|
||||
|
||||
static inline ulonglong
|
||||
inline_mysql_stage_get_work_completed(PSI_stage_progress *progress)
|
||||
{
|
||||
return progress->m_work_completed;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_stage_inc_work_completed(PSI_stage_progress *progress,
|
||||
ulonglong val)
|
||||
{
|
||||
if (progress != NULL)
|
||||
progress->m_work_completed+= val;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_stage_set_work_estimated(PSI_stage_progress *progress,
|
||||
ulonglong val)
|
||||
{
|
||||
if (progress != NULL)
|
||||
progress->m_work_estimated= val;
|
||||
}
|
||||
|
||||
static inline ulonglong
|
||||
inline_mysql_stage_get_work_estimated(PSI_stage_progress *progress)
|
||||
{
|
||||
return progress->m_work_estimated;
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Stage_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,242 @@
|
|||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_STATEMENT_H
|
||||
#define MYSQL_STATEMENT_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_statement.h
|
||||
Instrumentation helpers for statements.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
class Diagnostics_area;
|
||||
typedef struct charset_info_st CHARSET_INFO;
|
||||
|
||||
#ifndef PSI_STATEMENT_CALL
|
||||
#define PSI_STATEMENT_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
#ifndef PSI_DIGEST_CALL
|
||||
#define PSI_DIGEST_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Statement_instrumentation Statement Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_statement_register(P1, P2, P3)
|
||||
Statement registration.
|
||||
*/
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define mysql_statement_register(P1, P2, P3) \
|
||||
inline_mysql_statement_register(P1, P2, P3)
|
||||
#else
|
||||
#define mysql_statement_register(P1, P2, P3) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
#define MYSQL_DIGEST_START(LOCKER) \
|
||||
inline_mysql_digest_start(LOCKER)
|
||||
#else
|
||||
#define MYSQL_DIGEST_START(LOCKER) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
#define MYSQL_DIGEST_END(LOCKER, DIGEST) \
|
||||
inline_mysql_digest_end(LOCKER, DIGEST)
|
||||
#else
|
||||
#define MYSQL_DIGEST_END(LOCKER, DIGEST) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN, CS, SPS) \
|
||||
inline_mysql_start_statement(STATE, K, DB, DB_LEN, CS, SPS, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN, CS, SPS) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_REFINE_STATEMENT(LOCKER, K) \
|
||||
inline_mysql_refine_statement(LOCKER, K)
|
||||
#else
|
||||
#define MYSQL_REFINE_STATEMENT(LOCKER, K) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
|
||||
inline_mysql_set_statement_text(LOCKER, P1, P2)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
|
||||
inline_mysql_set_statement_lock_time(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
|
||||
inline_mysql_set_statement_rows_sent(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
|
||||
inline_mysql_set_statement_rows_examined(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_END_STATEMENT(LOCKER, DA) \
|
||||
inline_mysql_end_statement(LOCKER, DA)
|
||||
#else
|
||||
#define MYSQL_END_STATEMENT(LOCKER, DA) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
static inline void inline_mysql_statement_register(
|
||||
const char *category, PSI_statement_info *info, int count)
|
||||
{
|
||||
PSI_STATEMENT_CALL(register_statement)(category, info, count);
|
||||
}
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
static inline struct PSI_digest_locker *
|
||||
inline_mysql_digest_start(PSI_statement_locker *locker)
|
||||
{
|
||||
PSI_digest_locker* digest_locker= NULL;
|
||||
|
||||
if (likely(locker != NULL))
|
||||
digest_locker= PSI_DIGEST_CALL(digest_start)(locker);
|
||||
return digest_locker;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_digest_end(PSI_digest_locker *locker, const sql_digest_storage *digest)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_DIGEST_CALL(digest_end)(locker, digest);
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline struct PSI_statement_locker *
|
||||
inline_mysql_start_statement(PSI_statement_locker_state *state,
|
||||
PSI_statement_key key,
|
||||
const char *db, uint db_len,
|
||||
const CHARSET_INFO *charset,
|
||||
PSI_sp_share *sp_share,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
PSI_statement_locker *locker;
|
||||
locker= PSI_STATEMENT_CALL(get_thread_statement_locker)(state, key, charset,
|
||||
sp_share);
|
||||
if (likely(locker != NULL))
|
||||
PSI_STATEMENT_CALL(start_statement)(locker, db, db_len, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
|
||||
static inline struct PSI_statement_locker *
|
||||
inline_mysql_refine_statement(PSI_statement_locker *locker,
|
||||
PSI_statement_key key)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
locker= PSI_STATEMENT_CALL(refine_statement)(locker, key);
|
||||
}
|
||||
return locker;
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_text(PSI_statement_locker *locker,
|
||||
const char *text, uint text_len)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_text)(locker, text, text_len);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_lock_time(PSI_statement_locker *locker,
|
||||
ulonglong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_lock_time)(locker, count);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_rows_sent(PSI_statement_locker *locker,
|
||||
ulonglong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_rows_sent)(locker, count);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_rows_examined(PSI_statement_locker *locker,
|
||||
ulonglong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_rows_examined)(locker, count);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_end_statement(struct PSI_statement_locker *locker,
|
||||
Diagnostics_area *stmt_da)
|
||||
{
|
||||
PSI_STAGE_CALL(end_stage)();
|
||||
if (likely(locker != NULL))
|
||||
PSI_STATEMENT_CALL(end_statement)(locker, stmt_da);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Statement_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,149 @@
|
|||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_TABLE_H
|
||||
#define MYSQL_TABLE_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_table.h
|
||||
Instrumentation helpers for table io.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_TABLE_CALL
|
||||
#define PSI_TABLE_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Table_instrumentation Table Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def MYSQL_TABLE_WAIT_VARIABLES
|
||||
Instrumentation helper for table waits.
|
||||
This instrumentation declares local variables.
|
||||
Do not use a ';' after this macro
|
||||
@param LOCKER the locker
|
||||
@param STATE the locker state
|
||||
@sa MYSQL_START_TABLE_IO_WAIT.
|
||||
@sa MYSQL_END_TABLE_IO_WAIT.
|
||||
@sa MYSQL_START_TABLE_LOCK_WAIT.
|
||||
@sa MYSQL_END_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE) \
|
||||
struct PSI_table_locker* LOCKER; \
|
||||
PSI_table_locker_state STATE;
|
||||
#else
|
||||
#define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_START_TABLE_LOCK_WAIT
|
||||
Instrumentation helper for table lock waits.
|
||||
This instrumentation marks the start of a wait event.
|
||||
@param LOCKER the locker
|
||||
@param STATE the locker state
|
||||
@param PSI the instrumented table
|
||||
@param OP the table operation to be performed
|
||||
@param FLAGS per table operation flags.
|
||||
@sa MYSQL_END_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
|
||||
LOCKER= inline_mysql_start_table_lock_wait(STATE, PSI, \
|
||||
OP, FLAGS, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_END_TABLE_LOCK_WAIT
|
||||
Instrumentation helper for table lock waits.
|
||||
This instrumentation marks the end of a wait event.
|
||||
@param LOCKER the locker
|
||||
@sa MYSQL_START_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
|
||||
inline_mysql_end_table_lock_wait(LOCKER)
|
||||
#else
|
||||
#define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_UNLOCK_TABLE(T) \
|
||||
inline_mysql_unlock_table(T)
|
||||
#else
|
||||
#define MYSQL_UNLOCK_TABLE(T) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
/**
|
||||
Instrumentation calls for MYSQL_START_TABLE_LOCK_WAIT.
|
||||
@sa MYSQL_END_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
static inline struct PSI_table_locker *
|
||||
inline_mysql_start_table_lock_wait(PSI_table_locker_state *state,
|
||||
struct PSI_table *psi,
|
||||
enum PSI_table_lock_operation op,
|
||||
ulong flags, const char *src_file, int src_line)
|
||||
{
|
||||
if (psi != NULL)
|
||||
{
|
||||
struct PSI_table_locker *locker;
|
||||
locker= PSI_TABLE_CALL(start_table_lock_wait)
|
||||
(state, psi, op, flags, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
Instrumentation calls for MYSQL_END_TABLE_LOCK_WAIT.
|
||||
@sa MYSQL_START_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
static inline void
|
||||
inline_mysql_end_table_lock_wait(struct PSI_table_locker *locker)
|
||||
{
|
||||
if (locker != NULL)
|
||||
PSI_TABLE_CALL(end_table_lock_wait)(locker);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_unlock_table(struct PSI_table *table)
|
||||
{
|
||||
if (table != NULL)
|
||||
PSI_TABLE_CALL(unlock_table)(table);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Table_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,220 @@
|
|||
/* Copyright (c) 2013, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_TRANSACTION_H
|
||||
#define MYSQL_TRANSACTION_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_transaction.h
|
||||
Instrumentation helpers for transactions.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_TRANSACTION_CALL
|
||||
#define PSI_TRANSACTION_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Transaction_instrumentation Transaction Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_START_TRANSACTION(STATE, XID, TRXID, ISO, RO, AC) \
|
||||
inline_mysql_start_transaction(STATE, XID, TRXID, ISO, RO, AC, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_TRANSACTION(STATE, XID, TRXID, ISO, RO, AC) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_GTID(LOCKER, P1, P2) \
|
||||
inline_mysql_set_transaction_gtid(LOCKER, P1, P2)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_GTID(LOCKER, P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_XID(LOCKER, P1, P2) \
|
||||
inline_mysql_set_transaction_xid(LOCKER, P1, P2)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_XID(LOCKER, P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_XA_STATE(LOCKER, P1) \
|
||||
inline_mysql_set_transaction_xa_state(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_XA_STATE(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_TRXID(LOCKER, P1) \
|
||||
inline_mysql_set_transaction_trxid(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_TRXID(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_INC_TRANSACTION_SAVEPOINTS(LOCKER, P1) \
|
||||
inline_mysql_inc_transaction_savepoints(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_INC_TRANSACTION_SAVEPOINTS(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_INC_TRANSACTION_ROLLBACK_TO_SAVEPOINT(LOCKER, P1) \
|
||||
inline_mysql_inc_transaction_rollback_to_savepoint(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_INC_TRANSACTION_ROLLBACK_TO_SAVEPOINT(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_INC_TRANSACTION_RELEASE_SAVEPOINT(LOCKER, P1) \
|
||||
inline_mysql_inc_transaction_release_savepoint(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_INC_TRANSACTION_RELEASE_SAVEPOINT(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_ROLLBACK_TRANSACTION(LOCKER) \
|
||||
inline_mysql_rollback_transaction(LOCKER)
|
||||
#else
|
||||
#define MYSQL_ROLLBACK_TRANSACTION(LOCKER) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_COMMIT_TRANSACTION(LOCKER) \
|
||||
inline_mysql_commit_transaction(LOCKER)
|
||||
#else
|
||||
#define MYSQL_COMMIT_TRANSACTION(LOCKER) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
static inline struct PSI_transaction_locker *
|
||||
inline_mysql_start_transaction(PSI_transaction_locker_state *state,
|
||||
const void *xid,
|
||||
const ulonglong *trxid,
|
||||
int isolation_level,
|
||||
my_bool read_only,
|
||||
my_bool autocommit,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
PSI_transaction_locker *locker;
|
||||
locker= PSI_TRANSACTION_CALL(get_thread_transaction_locker)(state,
|
||||
xid, trxid,
|
||||
isolation_level,
|
||||
read_only,
|
||||
autocommit);
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(start_transaction)(locker, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_gtid(PSI_transaction_locker *locker,
|
||||
const void *sid,
|
||||
const void *gtid_spec)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_gtid)(locker, sid, gtid_spec);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_xid(PSI_transaction_locker *locker,
|
||||
const void *xid,
|
||||
int xa_state)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_xid)(locker, xid, xa_state);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_xa_state(PSI_transaction_locker *locker,
|
||||
int xa_state)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_xa_state)(locker, xa_state);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_trxid(PSI_transaction_locker *locker,
|
||||
const ulonglong *trxid)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_trxid)(locker, trxid);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_inc_transaction_savepoints(PSI_transaction_locker *locker,
|
||||
ulong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(inc_transaction_savepoints)(locker, count);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_inc_transaction_rollback_to_savepoint(PSI_transaction_locker *locker,
|
||||
ulong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(inc_transaction_rollback_to_savepoint)(locker, count);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_inc_transaction_release_savepoint(PSI_transaction_locker *locker,
|
||||
ulong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(inc_transaction_release_savepoint)(locker, count);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_rollback_transaction(struct PSI_transaction_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(end_transaction)(locker, false);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_commit_transaction(struct PSI_transaction_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(end_transaction)(locker, true);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Transaction_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,173 @@
|
|||
/* Copyright (c) 2008, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_PSI_BASE_H
|
||||
#define MYSQL_PSI_BASE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file mysql/psi/psi_base.h
|
||||
Performance schema instrumentation interface.
|
||||
|
||||
@defgroup Instrumentation_interface Instrumentation Interface
|
||||
@ingroup Performance_schema
|
||||
@{
|
||||
*/
|
||||
|
||||
#define PSI_INSTRUMENT_ME 0
|
||||
|
||||
#define PSI_NOT_INSTRUMENTED 0
|
||||
|
||||
/**
|
||||
Global flag.
|
||||
This flag indicate that an instrumentation point is a global variable,
|
||||
or a singleton.
|
||||
*/
|
||||
#define PSI_FLAG_GLOBAL (1 << 0)
|
||||
|
||||
/**
|
||||
Mutable flag.
|
||||
This flag indicate that an instrumentation point is a general placeholder,
|
||||
that can mutate into a more specific instrumentation point.
|
||||
*/
|
||||
#define PSI_FLAG_MUTABLE (1 << 1)
|
||||
|
||||
#define PSI_FLAG_THREAD (1 << 2)
|
||||
|
||||
/**
|
||||
Stage progress flag.
|
||||
This flag apply to the stage instruments only.
|
||||
It indicates the instrumentation provides progress data.
|
||||
*/
|
||||
#define PSI_FLAG_STAGE_PROGRESS (1 << 3)
|
||||
|
||||
/**
|
||||
Shared Exclusive flag.
|
||||
Indicates that rwlock support the shared exclusive state.
|
||||
*/
|
||||
#define PSI_RWLOCK_FLAG_SX (1 << 4)
|
||||
|
||||
/**
|
||||
Transferable flag.
|
||||
This flag indicate that an instrumented object can
|
||||
be created by a thread and destroyed by another thread.
|
||||
*/
|
||||
#define PSI_FLAG_TRANSFER (1 << 5)
|
||||
|
||||
/**
|
||||
Volatility flag.
|
||||
This flag indicate that an instrumented object
|
||||
has a volatility (life cycle) comparable
|
||||
to the volatility of a session.
|
||||
*/
|
||||
#define PSI_FLAG_VOLATILITY_SESSION (1 << 6)
|
||||
|
||||
/**
|
||||
System thread flag.
|
||||
Indicates that the instrumented object exists on a system thread.
|
||||
*/
|
||||
#define PSI_FLAG_THREAD_SYSTEM (1 << 9)
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
|
||||
/**
|
||||
@def PSI_VERSION_1
|
||||
Performance Schema Interface number for version 1.
|
||||
This version is supported.
|
||||
*/
|
||||
#define PSI_VERSION_1 1
|
||||
|
||||
/**
|
||||
@def PSI_VERSION_2
|
||||
Performance Schema Interface number for version 2.
|
||||
This version is not implemented, it's a placeholder.
|
||||
*/
|
||||
#define PSI_VERSION_2 2
|
||||
|
||||
/**
|
||||
@def PSI_CURRENT_VERSION
|
||||
Performance Schema Interface number for the most recent version.
|
||||
The most current version is @c PSI_VERSION_1
|
||||
*/
|
||||
#define PSI_CURRENT_VERSION 1
|
||||
|
||||
/**
|
||||
@def USE_PSI_1
|
||||
Define USE_PSI_1 to use the interface version 1.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def USE_PSI_2
|
||||
Define USE_PSI_2 to use the interface version 2.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def HAVE_PSI_1
|
||||
Define HAVE_PSI_1 if the interface version 1 needs to be compiled in.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def HAVE_PSI_2
|
||||
Define HAVE_PSI_2 if the interface version 2 needs to be compiled in.
|
||||
*/
|
||||
|
||||
#ifndef USE_PSI_2
|
||||
#ifndef USE_PSI_1
|
||||
#define USE_PSI_1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef USE_PSI_1
|
||||
#define HAVE_PSI_1
|
||||
#endif
|
||||
|
||||
#ifdef USE_PSI_2
|
||||
#define HAVE_PSI_2
|
||||
#endif
|
||||
|
||||
/*
|
||||
Allow to override PSI_XXX_CALL at compile time
|
||||
with more efficient implementations, if available.
|
||||
If nothing better is available,
|
||||
make a dynamic call using the PSI_server function pointer.
|
||||
*/
|
||||
|
||||
#define PSI_DYNAMIC_CALL(M) PSI_server->M
|
||||
|
||||
#endif /* HAVE_PSI_INTERFACE */
|
||||
|
||||
/** @} */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MYSQL_PSI_BASE_H */
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
/* Copyright (c) 2013, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_PSI_MEMORY_H
|
||||
#define MYSQL_PSI_MEMORY_H
|
||||
|
||||
#include "psi_base.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file mysql/psi/psi_memory.h
|
||||
Performance schema instrumentation interface.
|
||||
|
||||
@defgroup Instrumentation_interface Instrumentation Interface
|
||||
@ingroup Performance_schema
|
||||
@{
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#ifndef DISABLE_ALL_PSI
|
||||
#ifndef DISABLE_PSI_MEMORY
|
||||
#define HAVE_PSI_MEMORY_INTERFACE
|
||||
#endif /* DISABLE_PSI_MEMORY */
|
||||
#endif /* DISABLE_ALL_PSI */
|
||||
#endif /* HAVE_PSI_INTERFACE */
|
||||
|
||||
struct PSI_thread;
|
||||
|
||||
/**
|
||||
Instrumented memory key.
|
||||
To instrument memory, a memory key must be obtained using @c register_memory.
|
||||
Using a zero key always disable the instrumentation.
|
||||
*/
|
||||
typedef unsigned int PSI_memory_key;
|
||||
|
||||
#ifdef HAVE_PSI_1
|
||||
|
||||
/**
|
||||
@defgroup Group_PSI_v1 Application Binary Interface, version 1
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
Memory instrument information.
|
||||
@since PSI_VERSION_1
|
||||
This structure is used to register instrumented memory.
|
||||
*/
|
||||
struct PSI_memory_info_v1
|
||||
{
|
||||
/** Pointer to the key assigned to the registered memory. */
|
||||
PSI_memory_key *m_key;
|
||||
/** The name of the memory instrument to register. */
|
||||
const char *m_name;
|
||||
/**
|
||||
The flags of the socket instrument to register.
|
||||
@sa PSI_FLAG_GLOBAL
|
||||
*/
|
||||
int m_flags;
|
||||
};
|
||||
typedef struct PSI_memory_info_v1 PSI_memory_info_v1;
|
||||
|
||||
/**
|
||||
Memory registration API.
|
||||
@param category a category name (typically a plugin name)
|
||||
@param info an array of memory info to register
|
||||
@param count the size of the info array
|
||||
*/
|
||||
typedef void (*register_memory_v1_t)
|
||||
(const char *category, struct PSI_memory_info_v1 *info, int count);
|
||||
|
||||
/**
|
||||
Instrument memory allocation.
|
||||
@param key the memory instrument key
|
||||
@param size the size of memory allocated
|
||||
@param[out] owner the memory owner
|
||||
@return the effective memory instrument key
|
||||
*/
|
||||
typedef PSI_memory_key (*memory_alloc_v1_t)
|
||||
(PSI_memory_key key, size_t size, struct PSI_thread ** owner);
|
||||
|
||||
/**
|
||||
Instrument memory re allocation.
|
||||
@param key the memory instrument key
|
||||
@param old_size the size of memory previously allocated
|
||||
@param new_size the size of memory re allocated
|
||||
@param[in, out] owner the memory owner
|
||||
@return the effective memory instrument key
|
||||
*/
|
||||
typedef PSI_memory_key (*memory_realloc_v1_t)
|
||||
(PSI_memory_key key, size_t old_size, size_t new_size, struct PSI_thread ** owner);
|
||||
|
||||
/**
|
||||
Instrument memory claim.
|
||||
@param key the memory instrument key
|
||||
@param size the size of memory allocated
|
||||
@param[in, out] owner the memory owner
|
||||
@return the effective memory instrument key
|
||||
*/
|
||||
typedef PSI_memory_key (*memory_claim_v1_t)
|
||||
(PSI_memory_key key, size_t size, struct PSI_thread ** owner);
|
||||
|
||||
/**
|
||||
Instrument memory free.
|
||||
@param key the memory instrument key
|
||||
@param size the size of memory allocated
|
||||
@param owner the memory owner
|
||||
*/
|
||||
typedef void (*memory_free_v1_t)
|
||||
(PSI_memory_key key, size_t size, struct PSI_thread * owner);
|
||||
|
||||
/** @} (end of group Group_PSI_v1) */
|
||||
|
||||
#endif /* HAVE_PSI_1 */
|
||||
|
||||
#ifdef HAVE_PSI_2
|
||||
struct PSI_memory_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
|
||||
#endif /* HAVE_PSI_2 */
|
||||
|
||||
#ifdef USE_PSI_1
|
||||
typedef struct PSI_memory_info_v1 PSI_memory_info;
|
||||
#endif
|
||||
|
||||
#ifdef USE_PSI_2
|
||||
typedef struct PSI_memory_info_v2 PSI_memory_info;
|
||||
#endif
|
||||
|
||||
/** @} (end of group Instrumentation_interface) */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* MYSQL_PSI_MEMORY_H */
|
||||
|
|
@ -0,0 +1,442 @@
|
|||
#ifndef MYSQL_SERVICE_COMMAND_INCLUDED
|
||||
#define MYSQL_SERVICE_COMMAND_INCLUDED
|
||||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file
|
||||
Header file for the Command service. This service is to provide means
|
||||
of executing different commands, like COM_QUERY, COM_STMT_PREPARE,
|
||||
in the server.
|
||||
*/
|
||||
|
||||
#include "mysql/service_srv_session.h"
|
||||
#include "mysql/com_data.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "mysql_time.h"
|
||||
#include "decimal.h"
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include "m_ctype.h"
|
||||
#include <stdint.h> /* uint32_t */
|
||||
#endif
|
||||
|
||||
/* POD structure for the field metadata from the server */
|
||||
struct st_send_field
|
||||
{
|
||||
const char *db_name;
|
||||
const char *table_name;
|
||||
const char *org_table_name;
|
||||
const char *col_name;
|
||||
const char *org_col_name;
|
||||
unsigned long length;
|
||||
unsigned int charsetnr;
|
||||
unsigned int flags;
|
||||
unsigned int decimals;
|
||||
enum_field_types type;
|
||||
};
|
||||
|
||||
|
||||
struct st_command_service_cbs
|
||||
{
|
||||
/*
|
||||
For a statement that returns a result, the flow of called callbacks will be:
|
||||
|
||||
start_result_metadata()
|
||||
field_metadata()
|
||||
....
|
||||
end_result_metadata() (in the classic protocol this generates an EOF packet)
|
||||
start_row()
|
||||
get_xxx()
|
||||
...
|
||||
end_row()
|
||||
start_row()
|
||||
get_xxx()
|
||||
...
|
||||
end_row()
|
||||
handle_ok() (with data for an EOF packet)
|
||||
|
||||
For a statement that does NOT return a result, but only status, like
|
||||
INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, CREATE, DROP, ALTER, etc. only
|
||||
handle_ok() will be invoked, in case of success.
|
||||
|
||||
All statements that result in an error will invoke handle_error().
|
||||
|
||||
For statements that return a result set, handle_error() might be invoked
|
||||
even after metadata was sent. This will indicate an error during the
|
||||
execution of the statement.
|
||||
*/
|
||||
|
||||
/*** Getting metadata ***/
|
||||
/**
|
||||
Indicates beginning of metadata for the result set
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param num_cols Number of fields being sent
|
||||
@param flags Flags to alter the metadata sending
|
||||
@param resultcs Charset of the result set
|
||||
|
||||
@note resultcs is the charset in which the data should be encoded before
|
||||
sent to the client. This is the value of the session variable
|
||||
character_set_results. The implementor most probably will need to save
|
||||
this value in the context and use it as "to" charset in get_string().
|
||||
|
||||
In case of CS_BINARY_REPRESENTATION, get_string() receives as a parameter
|
||||
the charset of the string, as it is stored on disk.
|
||||
|
||||
In case of CS_TEXT_REPRESENTATION, the string value might be already a
|
||||
stringified value or non-string data, which is in character_set_results.
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*start_result_metadata)(void *ctx, uint num_cols, uint flags,
|
||||
const CHARSET_INFO *resultcs);
|
||||
|
||||
/**
|
||||
Field metadata is provided via this callback
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param field Field's metadata (see field.h)
|
||||
@param charset Field's charset
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*field_metadata)(void *ctx, struct st_send_field *field,
|
||||
const CHARSET_INFO *charset);
|
||||
|
||||
/**
|
||||
Indicates end of metadata for the result set
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param server_status Status of server (see mysql_com.h, SERVER_STATUS_*)
|
||||
@param warn_count Number of warnings generated during execution to the
|
||||
moment when the metadata is sent.
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*end_result_metadata)(void *ctx, uint server_status,
|
||||
uint warn_count);
|
||||
|
||||
/**
|
||||
Indicates the beginning of a new row in the result set/metadata
|
||||
|
||||
@param ctx Plugin's context
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*start_row)(void *ctx);
|
||||
|
||||
/**
|
||||
Indicates the end of the current row in the result set/metadata
|
||||
|
||||
@param ctx Plugin's context
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*end_row)(void *ctx);
|
||||
|
||||
/**
|
||||
An error occured during execution
|
||||
|
||||
@details This callback indicates that an error occured during command
|
||||
execution and the partial row should be dropped. Server will raise error
|
||||
and return.
|
||||
|
||||
@param ctx Plugin's context
|
||||
|
||||
@returns
|
||||
true an error occured, server will abort the command
|
||||
false ok
|
||||
|
||||
*/
|
||||
void (*abort_row)(void *ctx);
|
||||
|
||||
/**
|
||||
Return client's capabilities (see mysql_com.h, CLIENT_*)
|
||||
|
||||
@param ctx Plugin's context
|
||||
|
||||
@return Bitmap of client's capabilities
|
||||
*/
|
||||
ulong (*get_client_capabilities)(void *ctx);
|
||||
|
||||
/****** Getting data ******/
|
||||
/**
|
||||
Receive NULL value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_null)(void * ctx);
|
||||
|
||||
/**
|
||||
Receive TINY/SHORT/LONG value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
|
||||
@note In order to know which type exactly was received, the plugin must
|
||||
track the metadata that was sent just prior to the result set.
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_integer)(void * ctx, longlong value);
|
||||
|
||||
/**
|
||||
Get LONGLONG value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
@param is_unsigned TRUE <=> value is unsigned
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_longlong)(void * ctx, longlong value, uint is_unsigned);
|
||||
|
||||
/**
|
||||
Receive DECIMAL value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_decimal)(void * ctx, const decimal_t * value);
|
||||
|
||||
/**
|
||||
Receive FLOAT/DOUBLE from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
@param decimals Number of decimals
|
||||
|
||||
@note In order to know which type exactly was received, the plugin must
|
||||
track the metadata that was sent just prior to the result set.
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_double)(void * ctx, double value, uint32_t decimals);
|
||||
|
||||
/**
|
||||
Get DATE value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
|
||||
@returns
|
||||
1 an error occured during storing, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_date)(void * ctx, const MYSQL_TIME * value);
|
||||
|
||||
/**
|
||||
Receive TIME value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
@param decimals Number of decimals
|
||||
|
||||
@returns
|
||||
1 an error occured during storing, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_time)(void * ctx, const MYSQL_TIME * value, uint decimals);
|
||||
|
||||
/**
|
||||
Receive DATETIME value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Value received
|
||||
@param decimals Number of decimals
|
||||
|
||||
@returns
|
||||
1 an error occured during storing, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_datetime)(void * ctx, const MYSQL_TIME * value, uint decimals);
|
||||
|
||||
/**
|
||||
Get STRING value from server
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param value Data
|
||||
@param length Data length
|
||||
@param valuecs Data charset
|
||||
|
||||
@note In case of CS_BINARY_REPRESENTATION, get_string() receives as
|
||||
a parameter the charset of the string, as it is stored on disk.
|
||||
|
||||
In case of CS_TEXT_REPRESENTATION, the string value might be already a
|
||||
stringified value or non-string data, which is in character_set_results.
|
||||
|
||||
@see start_result_metadata()
|
||||
|
||||
@returns
|
||||
1 an error occured, server will abort the command
|
||||
0 ok
|
||||
*/
|
||||
int (*get_string)(void * ctx, const char * value, size_t length,
|
||||
const CHARSET_INFO * valuecs);
|
||||
|
||||
/****** Getting execution status ******/
|
||||
/**
|
||||
Command ended with success
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param server_status Status of server (see mysql_com.h,
|
||||
SERVER_STATUS_*)
|
||||
@param statement_warn_count Number of warnings thrown during execution
|
||||
@param affected_rows Number of rows affected by the command
|
||||
@param last_insert_id Last insert id being assigned during execution
|
||||
@param message A message from server
|
||||
*/
|
||||
void (*handle_ok)(void * ctx,
|
||||
uint server_status, uint statement_warn_count,
|
||||
ulonglong affected_rows, ulonglong last_insert_id,
|
||||
const char * message);
|
||||
|
||||
/**
|
||||
Command ended with ERROR
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param sql_errno Error code
|
||||
@param err_msg Error message
|
||||
@param sqlstate SQL state correspongin to the error code
|
||||
*/
|
||||
void (*handle_error)(void * ctx, uint sql_errno, const char * err_msg,
|
||||
const char * sqlstate);
|
||||
|
||||
/**
|
||||
Callback for shutdown notification from the server.
|
||||
|
||||
@param ctx Plugin's context
|
||||
@param server_shutdown Whether this is a normal connection shutdown (0) or
|
||||
server shutdown (1).
|
||||
*/
|
||||
void (*shutdown)(void *ctx, int server_shutdown);
|
||||
};
|
||||
|
||||
enum cs_text_or_binary
|
||||
{
|
||||
CS_TEXT_REPRESENTATION= 1, /* Let the server convert everything to string */
|
||||
CS_BINARY_REPRESENTATION= 2, /* Let the server use native types */
|
||||
};
|
||||
|
||||
extern struct command_service_st {
|
||||
int (*run_command)(MYSQL_SESSION session,
|
||||
enum enum_server_command command,
|
||||
const union COM_DATA * data,
|
||||
const CHARSET_INFO * client_cs,
|
||||
const struct st_command_service_cbs * callbacks,
|
||||
enum cs_text_or_binary text_or_binary,
|
||||
void * service_callbacks_ctx);
|
||||
} *command_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define command_service_run_command(t, command, data, cset, cbs, t_or_b, ctx) \
|
||||
command_service->run_command((t), (command), (data), (cset), \
|
||||
(cbs), (t_or_b), (ctx))
|
||||
#else
|
||||
|
||||
|
||||
/**
|
||||
Executes a server command in a session.
|
||||
|
||||
|
||||
There are two cases. Execution in a physical thread :
|
||||
1. initialized by the srv_session service
|
||||
2. NOT initialized by the srv_session service
|
||||
|
||||
In case of 1, if there is currently attached session, and it is
|
||||
different from the passed one, the former will be automatically
|
||||
detached. The session to be used for the execution will then be
|
||||
attached. After the command is executed, the attached session will
|
||||
not be detached. It will be detached by a next call to run_command()
|
||||
with another session as parameter. In other words, for all sessions
|
||||
used in a physical thread, there will be at most one in attached
|
||||
state.
|
||||
|
||||
In case of 2, the current state (current_thd) will be
|
||||
preserved. Then the given session will move to attached state and
|
||||
the command will be executed. After the execution the state of the
|
||||
session will be changed to detached and the preserved state
|
||||
(current_thd) will be restored.
|
||||
|
||||
The client charset is used for commands like COM_QUERY and
|
||||
COM_STMT_PREPARE to know how to threat the char* fields. This
|
||||
charset will be used until the next call of run_command when it may
|
||||
be changed again.
|
||||
|
||||
@param session The session
|
||||
@param command The command to be executed.
|
||||
@param data The data needed for the command to be executed
|
||||
@param client_cs The charset for the string data input(COM_QUERY for example)
|
||||
@param callbacks Callbacks to be used by the server to encode data and
|
||||
to communicate with the client (plugin) side.
|
||||
@param text_or_binary Select which representation the server will use for the
|
||||
data passed to the callbacks. For more information
|
||||
@see cs_text_or_binary enum
|
||||
@param service_callbacks_ctx Context passed to the command service callbacks
|
||||
|
||||
@return
|
||||
0 success
|
||||
1 failure
|
||||
*/
|
||||
int command_service_run_command(MYSQL_SESSION session,
|
||||
enum enum_server_command command,
|
||||
const union COM_DATA * data,
|
||||
const CHARSET_INFO * client_cs,
|
||||
const struct st_command_service_cbs * callbacks,
|
||||
enum cs_text_or_binary text_or_binary,
|
||||
void * service_callbacks_ctx);
|
||||
|
||||
#endif /* MYSQL_DYNAMIC_PLUGIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,121 @@
|
|||
/*
|
||||
Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef SERVICE_LOCKING_INCLUDED
|
||||
#define SERVICE_LOCKING_INCLUDED
|
||||
|
||||
/*
|
||||
This service provides support for taking read/write locks.
|
||||
It is intended for use with fabric, but it is still a general
|
||||
service. The locks are in a separate namespace from other
|
||||
locks in the server, and there is also no interactions with
|
||||
transactions (i.e. locks are not released on commit/abort).
|
||||
|
||||
These locks are implemented using the metadata lock (MDL) subsystem
|
||||
and thus deadlocks involving locking service locks and other types
|
||||
of metadata will be detected using the MDL deadlock detector.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
class THD;
|
||||
#define MYSQL_THD THD*
|
||||
#else
|
||||
#define MYSQL_THD void*
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
Types of locking service locks.
|
||||
LOCKING_SERVICE_READ is compatible with LOCKING_SERVICE_READ.
|
||||
All other combinations are incompatible.
|
||||
*/
|
||||
enum enum_locking_service_lock_type
|
||||
{ LOCKING_SERVICE_READ, LOCKING_SERVICE_WRITE };
|
||||
|
||||
extern struct mysql_locking_service_st {
|
||||
/**
|
||||
Acquire locking service locks.
|
||||
|
||||
@param opaque_thd Thread handle. If NULL, current_thd will be used.
|
||||
@param lock_namespace Namespace of the locks to acquire.
|
||||
@param lock_names Array of names of the locks to acquire.
|
||||
@param lock_num Number of elements in 'lock_names'.
|
||||
@param lock_type Lock type to acquire. LOCKING_SERVICE_READ or _WRITE.
|
||||
@param lock_timeout Number of seconds to wait before giving up.
|
||||
|
||||
@retval 1 Acquisition failed, error has been reported.
|
||||
@retval 0 Acquisition successful, all locks acquired.
|
||||
|
||||
@note both lock_namespace and lock_names are limited to 64 characters max.
|
||||
Names are compared using binary comparison.
|
||||
*/
|
||||
int (*mysql_acquire_locks)(MYSQL_THD opaque_thd, const char* lock_namespace,
|
||||
const char**lock_names, size_t lock_num,
|
||||
enum enum_locking_service_lock_type lock_type,
|
||||
unsigned long lock_timeout);
|
||||
|
||||
/**
|
||||
Release all lock service locks taken by the given connection
|
||||
in the given namespace.
|
||||
|
||||
@param opaque_thd Thread handle. If NULL, current_thd will be used.
|
||||
@param lock_namespace Namespace of the locks to release.
|
||||
|
||||
@retval 1 Release failed, error has been reported.
|
||||
@retval 0 Release successful, all locks acquired.
|
||||
*/
|
||||
int (*mysql_release_locks)(MYSQL_THD opaque_thd, const char* lock_namespace);
|
||||
} *mysql_locking_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define mysql_acquire_locking_service_locks(_THD, _NAMESPACE, _NAMES, _NUM, \
|
||||
_TYPE, _TIMEOUT) \
|
||||
mysql_locking_service->mysql_acquire_locks(_THD, _NAMESPACE, _NAMES, _NUM, \
|
||||
_TYPE, _TIMEOUT)
|
||||
#define mysql_release_locking_service_locks(_THD, _NAMESPACE) \
|
||||
mysql_locking_service->mysql_release_locks(_THD, _NAMESPACE)
|
||||
|
||||
#else
|
||||
|
||||
int mysql_acquire_locking_service_locks(MYSQL_THD opaque_thd,
|
||||
const char* lock_namespace,
|
||||
const char**lock_names,
|
||||
size_t lock_num,
|
||||
enum enum_locking_service_lock_type lock_type,
|
||||
unsigned long lock_timeout);
|
||||
|
||||
int mysql_release_locking_service_locks(MYSQL_THD opaque_thd,
|
||||
const char* lock_namespace);
|
||||
|
||||
#endif /* MYSQL_DYNAMIC_PLUGIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* SERVICE_LOCKING_INCLUDED */
|
|
@ -0,0 +1,70 @@
|
|||
/* Copyright (c) 2011, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file
|
||||
This service provides functions to report error conditions and log to
|
||||
mysql error log.
|
||||
*/
|
||||
|
||||
#ifndef MYSQL_SERVICE_MY_PLUGIN_LOG_INCLUDED
|
||||
#define MYSQL_SERVICE_MY_PLUGIN_LOG_INCLUDED
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdarg.h>
|
||||
#endif
|
||||
|
||||
/* keep in sync with the loglevel enum in my_sys.h */
|
||||
enum plugin_log_level
|
||||
{
|
||||
MY_ERROR_LEVEL,
|
||||
MY_WARNING_LEVEL,
|
||||
MY_INFORMATION_LEVEL
|
||||
};
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern struct my_plugin_log_service
|
||||
{
|
||||
/** write a message to the log */
|
||||
int (*my_plugin_log_message)(MYSQL_PLUGIN *, enum plugin_log_level, const char *, ...);
|
||||
} *my_plugin_log_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define my_plugin_log_message my_plugin_log_service->my_plugin_log_message
|
||||
|
||||
#else
|
||||
|
||||
int my_plugin_log_message(MYSQL_PLUGIN *plugin, enum plugin_log_level level,
|
||||
const char *format, ...);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,108 @@
|
|||
#ifndef MYSQL_SERVICE_MY_SNPRINTF_INCLUDED
|
||||
#define MYSQL_SERVICE_MY_SNPRINTF_INCLUDED
|
||||
/* Copyright (c) 2009, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file
|
||||
my_snprintf service
|
||||
|
||||
Portable and limited vsnprintf() implementation.
|
||||
|
||||
This is a portable, limited vsnprintf() implementation, with some
|
||||
extra features. "Portable" means that it'll produce identical result
|
||||
on all platforms (for example, on Windows and Linux system printf %e
|
||||
formats the exponent differently, on different systems %p either
|
||||
prints leading 0x or not, %s may accept null pointer or crash on
|
||||
it). "Limited" means that it does not support all the C89 features.
|
||||
But it supports few extensions, not in any standard.
|
||||
|
||||
my_vsnprintf(to, n, fmt, ap)
|
||||
|
||||
@param[out] to A buffer to store the result in
|
||||
@param[in] n Store up to n-1 characters, followed by an end 0
|
||||
@param[in] fmt printf-like format string
|
||||
@param[in] ap Arguments
|
||||
|
||||
@return a number of bytes written to a buffer *excluding* terminating '\0'
|
||||
|
||||
@post
|
||||
The syntax of a format string is generally the same:
|
||||
% <flag> <width> <precision> <length modifier> <format>
|
||||
where everithing but the format is optional.
|
||||
|
||||
Three one-character flags are recognized:
|
||||
'0' has the standard zero-padding semantics;
|
||||
'-' is parsed, but silently ignored;
|
||||
'`' (backtick) is only supported for strings (%s) and means that the
|
||||
string will be quoted according to MySQL identifier quoting rules.
|
||||
|
||||
Both <width> and <precision> can be specified as numbers or '*'.
|
||||
If an asterisk is used, an argument of type int is consumed.
|
||||
|
||||
<length modifier> can be 'l', 'll', or 'z'.
|
||||
|
||||
Supported formats are 's' (null pointer is accepted, printed as
|
||||
"(null)"), 'b' (extension, see below), 'c', 'd', 'i', 'u', 'x', 'o',
|
||||
'X', 'p' (works as 0x%x).
|
||||
|
||||
Standard syntax for positional arguments $n is supported.
|
||||
|
||||
Extensions:
|
||||
|
||||
Flag '`' (backtick): see above.
|
||||
|
||||
Format 'b': binary buffer, prints exactly <precision> bytes from the
|
||||
argument, without stopping at '\0'.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
extern struct my_snprintf_service_st {
|
||||
size_t (*my_snprintf_type)(char*, size_t, const char*, ...);
|
||||
size_t (*my_vsnprintf_type)(char *, size_t, const char*, va_list);
|
||||
} *my_snprintf_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define my_vsnprintf my_snprintf_service->my_vsnprintf_type
|
||||
#define my_snprintf my_snprintf_service->my_snprintf_type
|
||||
|
||||
#else
|
||||
|
||||
size_t my_snprintf(char* to, size_t n, const char* fmt, ...);
|
||||
size_t my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* #define MYSQL_SERVICE_MY_SNPRINTF_INCLUDED */
|
|
@ -0,0 +1,88 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_MYSQL_ALLOC_INCLUDED
|
||||
#define MYSQL_SERVICE_MYSQL_ALLOC_INCLUDED
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
/* PSI_memory_key */
|
||||
#include "mysql/psi/psi_memory.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* myf */
|
||||
typedef int myf_t;
|
||||
|
||||
typedef void * (*mysql_malloc_t)(PSI_memory_key key, size_t size, myf_t flags);
|
||||
typedef void * (*mysql_realloc_t)(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
|
||||
typedef void (*mysql_claim_t)(void *ptr);
|
||||
typedef void (*mysql_free_t)(void *ptr);
|
||||
typedef void * (*my_memdup_t)(PSI_memory_key key, const void *from, size_t length, myf_t flags);
|
||||
typedef char * (*my_strdup_t)(PSI_memory_key key, const char *from, myf_t flags);
|
||||
typedef char * (*my_strndup_t)(PSI_memory_key key, const char *from, size_t length, myf_t flags);
|
||||
|
||||
struct mysql_malloc_service_st
|
||||
{
|
||||
mysql_malloc_t mysql_malloc;
|
||||
mysql_realloc_t mysql_realloc;
|
||||
mysql_claim_t mysql_claim;
|
||||
mysql_free_t mysql_free;
|
||||
my_memdup_t my_memdup;
|
||||
my_strdup_t my_strdup;
|
||||
my_strndup_t my_strndup;
|
||||
};
|
||||
|
||||
extern struct mysql_malloc_service_st *mysql_malloc_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define my_malloc mysql_malloc_service->mysql_malloc
|
||||
#define my_realloc mysql_malloc_service->mysql_realloc
|
||||
#define my_claim mysql_malloc_service->mysql_claim
|
||||
#define my_free mysql_malloc_service->mysql_free
|
||||
#define my_memdup mysql_malloc_service->my_memdup
|
||||
#define my_strdup mysql_malloc_service->my_strdup
|
||||
#define my_strndup mysql_malloc_service->my_strndup
|
||||
|
||||
#else
|
||||
|
||||
extern void * my_malloc(PSI_memory_key key, size_t size, myf_t flags);
|
||||
extern void * my_realloc(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
|
||||
extern void my_claim(void *ptr);
|
||||
extern void my_free(void *ptr);
|
||||
extern void * my_memdup(PSI_memory_key key, const void *from, size_t length, myf_t flags);
|
||||
extern char * my_strdup(PSI_memory_key key, const char *from, myf_t flags);
|
||||
extern char * my_strndup(PSI_memory_key key, const char *from, size_t length, myf_t flags);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
/* Copyright (c) 2014, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_MYSQL_PLUGIN_KEYRING_INCLUDED
|
||||
#define MYSQL_SERVICE_MYSQL_PLUGIN_KEYRING_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern struct mysql_keyring_service_st
|
||||
{
|
||||
int (*my_key_store_func)(const char *, const char *, const char *,
|
||||
const void *, size_t);
|
||||
int (*my_key_fetch_func)(const char *, char **, const char *, void **,
|
||||
size_t *);
|
||||
int (*my_key_remove_func)(const char *, const char *);
|
||||
int (*my_key_generate_func)(const char *, const char *, const char *,
|
||||
size_t);
|
||||
} *mysql_keyring_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define my_key_store(key_id, key_type, user_id, key, key_len) \
|
||||
mysql_keyring_service->my_key_store_func(key_id, key_type, user_id, key, \
|
||||
key_len)
|
||||
#define my_key_fetch(key_id, key_type, user_id, key, key_len) \
|
||||
mysql_keyring_service->my_key_fetch_func(key_id, key_type, user_id, key, \
|
||||
key_len)
|
||||
#define my_key_remove(key_id, user_id) \
|
||||
mysql_keyring_service->my_key_remove_func(key_id, user_id)
|
||||
#define my_key_generate(key_id, key_type, user_id, key_len) \
|
||||
mysql_keyring_service->my_key_generate_func(key_id, key_type, user_id, \
|
||||
key_len)
|
||||
#else
|
||||
|
||||
int my_key_store(const char *, const char *, const char *, const void *, size_t);
|
||||
int my_key_fetch(const char *, char **, const char *, void **,
|
||||
size_t *);
|
||||
int my_key_remove(const char *, const char *);
|
||||
int my_key_generate(const char *, const char *, const char *, size_t);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //MYSQL_SERVICE_MYSQL_PLUGIN_KEYRING_INCLUDED
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
/* Copyright (c) 2014, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_MYSQL_PLUGIN_AUTH_INCLUDED
|
||||
#define MYSQL_SERVICE_MYSQL_PLUGIN_AUTH_INCLUDED
|
||||
|
||||
/**
|
||||
@file include/mysql/service_mysql_plugin_auth.h
|
||||
This service provides functions to validatete password, check for strength
|
||||
of password based on common policy.
|
||||
|
||||
SYNOPSIS
|
||||
my_validate_password_policy() - function to validate password
|
||||
based on defined policy
|
||||
const char* buffer holding the password value
|
||||
unsigned int buffer length
|
||||
|
||||
my_calculate_password_strength() - function to calculate strength
|
||||
of the password based on the policies defined.
|
||||
const char* buffer holding the password value
|
||||
unsigned int buffer length
|
||||
|
||||
Both the service function returns 0 on SUCCESS and 1 incase input password does not
|
||||
match against the policy rules defined.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern struct mysql_password_policy_service_st {
|
||||
int (*my_validate_password_policy_func)(const char *, unsigned int);
|
||||
int (*my_calculate_password_strength_func)(const char *, unsigned int);
|
||||
} *mysql_password_policy_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define my_validate_password_policy(buffer, length) \
|
||||
mysql_password_policy_service->my_validate_password_policy_func(buffer, length)
|
||||
#define my_calculate_password_strength(buffer, length) \
|
||||
mysql_password_policy_service->my_calculate_password_strength_func(buffer, length)
|
||||
|
||||
#else
|
||||
|
||||
int my_validate_password_policy(const char *, unsigned int);
|
||||
int my_calculate_password_strength(const char *, unsigned int);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,140 @@
|
|||
/* Copyright (c) 2012, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/* This service provides functions to parse mysql String */
|
||||
|
||||
#ifndef MYSQL_SERVICE_MYSQL_STRING_INCLUDED
|
||||
#define MYSQL_SERVICE_MYSQL_STRING_INCLUDED
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void *mysql_string_iterator_handle;
|
||||
typedef void *mysql_string_handle;
|
||||
|
||||
extern struct mysql_string_service_st {
|
||||
int (*mysql_string_convert_to_char_ptr_type)
|
||||
(mysql_string_handle, const char *, char *, unsigned int, int *);
|
||||
mysql_string_iterator_handle (*mysql_string_get_iterator_type)
|
||||
(mysql_string_handle);
|
||||
int (*mysql_string_iterator_next_type)(mysql_string_iterator_handle);
|
||||
int (*mysql_string_iterator_isupper_type)(mysql_string_iterator_handle);
|
||||
int (*mysql_string_iterator_islower_type)(mysql_string_iterator_handle);
|
||||
int (*mysql_string_iterator_isdigit_type)(mysql_string_iterator_handle);
|
||||
mysql_string_handle (*mysql_string_to_lowercase_type)(mysql_string_handle);
|
||||
void (*mysql_string_free_type)(mysql_string_handle);
|
||||
void (*mysql_string_iterator_free_type)(mysql_string_iterator_handle);
|
||||
} *mysql_string_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define mysql_string_convert_to_char_ptr(string_handle, charset_name, \
|
||||
buffer, buffer_size, error) \
|
||||
mysql_string_service->mysql_string_convert_to_char_ptr_type \
|
||||
(string_handle, charset_name, buffer, \
|
||||
buffer_size, error)
|
||||
|
||||
#define mysql_string_get_iterator(string_handle) \
|
||||
mysql_string_service->mysql_string_get_iterator_type(string_handle)
|
||||
|
||||
#define mysql_string_iterator_next(iterator_handle) \
|
||||
mysql_string_service->mysql_string_iterator_next_type(iterator_handle)
|
||||
|
||||
#define mysql_string_iterator_isupper(iterator_handle) \
|
||||
mysql_string_service->mysql_string_iterator_isupper_type \
|
||||
(iterator_handle)
|
||||
|
||||
#define mysql_string_iterator_islower(iterator_handle) \
|
||||
mysql_string_service->mysql_string_iterator_islower_type \
|
||||
(iterator_handle)
|
||||
|
||||
#define mysql_string_iterator_isdigit(iterator_handle) \
|
||||
mysql_string_service->mysql_string_iterator_isdigit_type \
|
||||
(iterator_handle)
|
||||
|
||||
#define mysql_string_to_lowercase(string_handle) \
|
||||
mysql_string_service->mysql_string_to_lowercase_type(string_handle)
|
||||
|
||||
#define mysql_string_free(mysql_string_handle) \
|
||||
mysql_string_service->mysql_string_free_type(mysql_string_handle)
|
||||
|
||||
#define mysql_string_iterator_free(mysql_string_iterator_handle) \
|
||||
mysql_string_service->mysql_string_iterator_free_type \
|
||||
(mysql_string_iterator_handle)
|
||||
#else
|
||||
|
||||
/* This service function convert string into given character set */
|
||||
int mysql_string_convert_to_char_ptr(mysql_string_handle string_handle,
|
||||
const char *charset_name, char *buffer,
|
||||
unsigned int buffer_size, int *error);
|
||||
|
||||
/* This service function returns the beginning of the iterator handle */
|
||||
mysql_string_iterator_handle mysql_string_get_iterator(mysql_string_handle
|
||||
string_handle);
|
||||
/*
|
||||
This service function gets the next iterator handle
|
||||
returns 0 if reached the end else return 1
|
||||
*/
|
||||
int mysql_string_iterator_next(mysql_string_iterator_handle iterator_handle);
|
||||
|
||||
/*
|
||||
This service function return 1 if current iterator handle points to a
|
||||
uppercase character else return 0 for client character set.
|
||||
*/
|
||||
int mysql_string_iterator_isupper(mysql_string_iterator_handle iterator_handle);
|
||||
|
||||
/*
|
||||
This service function return 1 if current iterator handle points to a
|
||||
lowercase character else return 0 for client character set.
|
||||
*/
|
||||
int mysql_string_iterator_islower(mysql_string_iterator_handle iterator_handle);
|
||||
|
||||
/*
|
||||
This service function return 1 if current iterator handle points to a digit
|
||||
else return 0 for client character sets.
|
||||
*/
|
||||
int mysql_string_iterator_isdigit(mysql_string_iterator_handle iterator_handle);
|
||||
|
||||
/* convert string_handle into lowercase */
|
||||
mysql_string_handle mysql_string_to_lowercase(mysql_string_handle
|
||||
string_handle);
|
||||
|
||||
/* It deallocates the string created on server side during plugin operations */
|
||||
void mysql_string_free(mysql_string_handle);
|
||||
|
||||
/*
|
||||
It deallocates the string iterator created on server side
|
||||
during plugin operations
|
||||
*/
|
||||
void mysql_string_iterator_free(mysql_string_iterator_handle);
|
||||
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,292 @@
|
|||
#ifndef MYSQL_SERVICE_PARSER_INCLUDED
|
||||
#define MYSQL_SERVICE_PARSER_INCLUDED
|
||||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#include "my_md5_size.h"
|
||||
#include <mysql/mysql_lex_string.h>
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
class THD;
|
||||
class Item;
|
||||
#define MYSQL_THD THD*
|
||||
typedef Item* MYSQL_ITEM;
|
||||
#else
|
||||
#define MYSQL_THD void*
|
||||
typedef void* MYSQL_ITEM;
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file service_parser
|
||||
|
||||
Plugin service that provides access to the parser and some operations on the
|
||||
parse tree.
|
||||
*/
|
||||
|
||||
#define PARSER_SERVICE_DIGEST_LENGTH MD5_HASH_SIZE
|
||||
|
||||
#define STATEMENT_TYPE_SELECT 1
|
||||
#define STATEMENT_TYPE_OTHER 2
|
||||
|
||||
typedef
|
||||
int (*parse_node_visit_function)(MYSQL_ITEM item, unsigned char* arg);
|
||||
|
||||
|
||||
typedef
|
||||
int (*sql_condition_handler_function)(int sql_errno,
|
||||
const char* sqlstate,
|
||||
const char* msg,
|
||||
void *state);
|
||||
|
||||
struct st_my_thread_handle;
|
||||
|
||||
extern struct mysql_parser_service_st {
|
||||
|
||||
MYSQL_THD (*mysql_current_session)();
|
||||
|
||||
MYSQL_THD (*mysql_open_session)();
|
||||
|
||||
void (*mysql_start_thread)(MYSQL_THD thd, void *(*callback_fun)(void*),
|
||||
void *arg,
|
||||
struct st_my_thread_handle *thread_handle);
|
||||
|
||||
void (*mysql_join_thread)(struct st_my_thread_handle *thread_handle);
|
||||
|
||||
void (*mysql_set_current_database)(MYSQL_THD thd, const MYSQL_LEX_STRING db);
|
||||
|
||||
/**
|
||||
Parses the query.
|
||||
|
||||
@param thd The session in which to parse.
|
||||
|
||||
@param query The query to parse.
|
||||
|
||||
@param is_prepared If non-zero, the query will be parsed as a prepared
|
||||
statement and won't throw errors when the query string contains '?'.
|
||||
|
||||
@param handle_condition Callback function that is called if a condition is
|
||||
raised during the preparation, parsing or cleanup after parsing. If this
|
||||
argument is non-NULL, the diagnostics area will be cleared before this
|
||||
function returns.
|
||||
|
||||
@param condition_handler_state Will be passed to handle_condition when
|
||||
called. Otherwise ignored.
|
||||
|
||||
@retval 0 Success.
|
||||
@retval 1 Parse error.
|
||||
*/
|
||||
int (*mysql_parse)(MYSQL_THD thd, const MYSQL_LEX_STRING query,
|
||||
unsigned char is_prepared,
|
||||
sql_condition_handler_function handle_condition,
|
||||
void *condition_handler_state);
|
||||
|
||||
int (*mysql_get_statement_type)(MYSQL_THD thd);
|
||||
|
||||
/**
|
||||
Returns the digest of the last parsed statement in the session.
|
||||
|
||||
@param thd The session in which the statement was parsed.
|
||||
|
||||
@param digest[out] An area of at least size PARSER_SERVICE_DIGEST_LENGTH,
|
||||
where the digest is written.
|
||||
|
||||
@retval 0 Success.
|
||||
@retval 1 Parse error.
|
||||
*/
|
||||
int (*mysql_get_statement_digest)(MYSQL_THD thd, unsigned char *digest);
|
||||
|
||||
|
||||
/**
|
||||
Returns the number of parameters ('?') in the parsed query.
|
||||
This works only if the last query was parsed as a prepared statement.
|
||||
|
||||
@param thd The session in which the query was parsed.
|
||||
|
||||
@return The number of parameter markers.
|
||||
*/
|
||||
int (*mysql_get_number_params)(MYSQL_THD thd);
|
||||
|
||||
|
||||
/**
|
||||
Stores in 'positions' the positions in the last parsed query of each
|
||||
parameter marker('?'). Positions must be an already allocated array of at
|
||||
least mysql_parser_service_st::mysql_get_number_params() size. This works
|
||||
only if the last query was parsed as a prepared statement.
|
||||
|
||||
@param thd The session in which the query was parsed.
|
||||
|
||||
@param positions An already allocated array of at least
|
||||
mysql_parser_service_st::mysql_get_number_params() size.
|
||||
|
||||
@return The number of parameter markers and hence number of written
|
||||
positions.
|
||||
*/
|
||||
int (*mysql_extract_prepared_params)(MYSQL_THD thd, int *positions);
|
||||
|
||||
|
||||
/**
|
||||
Walks the tree depth first and applies a user defined function on each
|
||||
literal.
|
||||
|
||||
@param thd The session in which the query was parsed.
|
||||
|
||||
@param processor Will be called for each literal in the parse tree.
|
||||
|
||||
@param arg Will be passed as argument to each call to 'processor'.
|
||||
*/
|
||||
int (*mysql_visit_tree)(MYSQL_THD thd, parse_node_visit_function processor,
|
||||
unsigned char* arg);
|
||||
|
||||
|
||||
/**
|
||||
Renders the MYSQL_ITEM as a string and returns a reference in the form of
|
||||
a MYSQL_LEX_STRING. The string buffer is allocated by the server and must
|
||||
be freed by mysql_free_string().
|
||||
|
||||
@param item The literal to print.
|
||||
|
||||
@return The result of printing the literal.
|
||||
|
||||
@see mysql_parser_service_st::mysql_free_string().
|
||||
*/
|
||||
MYSQL_LEX_STRING (*mysql_item_string)(MYSQL_ITEM item);
|
||||
|
||||
|
||||
/**
|
||||
Frees a string buffer allocated by the server.
|
||||
|
||||
@param The string whose buffer will be freed.
|
||||
*/
|
||||
void (*mysql_free_string)(MYSQL_LEX_STRING string);
|
||||
|
||||
|
||||
/**
|
||||
Returns the current query string. This string is managed by the server and
|
||||
should @b not be freed by a plugin.
|
||||
|
||||
@param thd The session in which the query was submitted.
|
||||
|
||||
@return The query string.
|
||||
*/
|
||||
MYSQL_LEX_STRING (*mysql_get_query)(MYSQL_THD thd);
|
||||
|
||||
|
||||
/**
|
||||
Returns the current query in normalized form. This string is managed by
|
||||
the server and should @b not be freed by a plugin.
|
||||
|
||||
@param thd The session in which the query was submitted.
|
||||
|
||||
@return The query string normalized.
|
||||
*/
|
||||
MYSQL_LEX_STRING (*mysql_get_normalized_query)(MYSQL_THD thd);
|
||||
} *mysql_parser_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define mysql_parser_current_session() \
|
||||
mysql_parser_service->mysql_current_session()
|
||||
|
||||
#define mysql_parser_open_session() \
|
||||
mysql_parser_service->mysql_open_session()
|
||||
|
||||
#define mysql_parser_start_thread(thd, func, arg, thread_handle) \
|
||||
mysql_parser_service->mysql_start_thread(thd, func, arg, thread_handle)
|
||||
|
||||
#define mysql_parser_join_thread(thread_handle) \
|
||||
mysql_parser_service->mysql_join_thread(thread_handle)
|
||||
|
||||
#define mysql_parser_set_current_database(thd, db) \
|
||||
mysql_parser_service->mysql_set_current_database(thd, db)
|
||||
|
||||
#define mysql_parser_parse(thd, query, is_prepared, \
|
||||
condition_handler, condition_handler_state) \
|
||||
mysql_parser_service->mysql_parse(thd, query, is_prepared, \
|
||||
condition_handler, \
|
||||
condition_handler_state)
|
||||
|
||||
#define mysql_parser_get_statement_type(thd) \
|
||||
mysql_parser_service->mysql_get_statement_type(thd)
|
||||
|
||||
#define mysql_parser_get_statement_digest(thd, digest) \
|
||||
mysql_parser_service->mysql_get_statement_digest(thd, digest)
|
||||
|
||||
#define mysql_parser_get_number_params(thd) \
|
||||
mysql_parser_service->mysql_get_number_params(thd)
|
||||
|
||||
#define mysql_parser_extract_prepared_params(thd, positions) \
|
||||
mysql_parser_service->mysql_extract_prepared_params(thd, positions)
|
||||
|
||||
#define mysql_parser_visit_tree(thd, processor, arg) \
|
||||
mysql_parser_service->mysql_visit_tree(thd, processor, arg)
|
||||
|
||||
#define mysql_parser_item_string(item) \
|
||||
mysql_parser_service->mysql_item_string(item)
|
||||
|
||||
#define mysql_parser_free_string(string) \
|
||||
mysql_parser_service->mysql_free_string(string)
|
||||
|
||||
#define mysql_parser_get_query(thd) \
|
||||
mysql_parser_service->mysql_get_query(thd)
|
||||
|
||||
#define mysql_parser_get_normalized_query(thd) \
|
||||
mysql_parser_service->mysql_get_normalized_query(thd)
|
||||
|
||||
#else
|
||||
typedef void *(*callback_function)(void*);
|
||||
MYSQL_THD mysql_parser_current_session();
|
||||
MYSQL_THD mysql_parser_open_session();
|
||||
void mysql_parser_start_thread(MYSQL_THD thd, callback_function fun, void *arg,
|
||||
struct st_my_thread_handle *thread_handle);
|
||||
void mysql_parser_join_thread(struct st_my_thread_handle *thread_handle);
|
||||
void mysql_parser_set_current_database(MYSQL_THD thd,
|
||||
const MYSQL_LEX_STRING db);
|
||||
int mysql_parser_parse(MYSQL_THD thd, const MYSQL_LEX_STRING query,
|
||||
unsigned char is_prepared,
|
||||
sql_condition_handler_function handle_condition,
|
||||
void *condition_handler_state);
|
||||
int mysql_parser_get_statement_type(MYSQL_THD thd);
|
||||
int mysql_parser_get_statement_digest(MYSQL_THD thd, unsigned char *digest);
|
||||
int mysql_parser_get_number_params(MYSQL_THD thd);
|
||||
int mysql_parser_extract_prepared_params(MYSQL_THD thd, int *positions);
|
||||
int mysql_parser_visit_tree(MYSQL_THD thd, parse_node_visit_function processor,
|
||||
unsigned char* arg);
|
||||
MYSQL_LEX_STRING mysql_parser_item_string(MYSQL_ITEM item);
|
||||
void mysql_parser_free_string(MYSQL_LEX_STRING string);
|
||||
MYSQL_LEX_STRING mysql_parser_get_query(MYSQL_THD thd);
|
||||
MYSQL_LEX_STRING mysql_parser_get_normalized_query(MYSQL_THD thd);
|
||||
|
||||
#endif /* MYSQL_DYNAMIC_PLUGIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MYSQL_SERVICE_PARSER_INCLUDED */
|
|
@ -0,0 +1,88 @@
|
|||
/* Copyright (c) 2014, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_RPL_TRANSACTION_CTX_INCLUDED
|
||||
|
||||
/**
|
||||
@file include/mysql/service_rpl_transaction_ctx.h
|
||||
This service provides a function for plugins to report if a transaction of a
|
||||
given THD should continue or be aborted.
|
||||
|
||||
SYNOPSIS
|
||||
set_transaction_ctx()
|
||||
should be called during RUN_HOOK macro, on which we know that thread is
|
||||
on plugin context and it is before
|
||||
Rpl_transaction_ctx::is_transaction_rollback() check.
|
||||
*/
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct st_transaction_termination_ctx
|
||||
{
|
||||
unsigned long m_thread_id;
|
||||
unsigned int m_flags; // reserved
|
||||
|
||||
/*
|
||||
If the instruction is to rollback the transaction,
|
||||
then this flag is set to false.
|
||||
Note: type is char like on my_bool.
|
||||
*/
|
||||
char m_rollback_transaction;
|
||||
|
||||
/*
|
||||
If the plugin has generated a GTID, then the follwoing
|
||||
fields MUST be set.
|
||||
Note: type is char like on my_bool.
|
||||
*/
|
||||
char m_generated_gtid;
|
||||
int m_sidno;
|
||||
long long int m_gno;
|
||||
};
|
||||
typedef struct st_transaction_termination_ctx Transaction_termination_ctx;
|
||||
|
||||
extern struct rpl_transaction_ctx_service_st {
|
||||
int (*set_transaction_ctx)(Transaction_termination_ctx transaction_termination_ctx);
|
||||
} *rpl_transaction_ctx_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define set_transaction_ctx(transaction_termination_ctx) \
|
||||
(rpl_transaction_ctx_service->set_transaction_ctx((transaction_termination_ctx)))
|
||||
|
||||
#else
|
||||
|
||||
int set_transaction_ctx(Transaction_termination_ctx transaction_termination_ctx);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#define MYSQL_SERVICE_RPL_TRANSACTION_CTX_INCLUDED
|
||||
#endif
|
|
@ -0,0 +1,102 @@
|
|||
/* Copyright (c) 2014, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_TRANSACTION_WRITE_SET_INCLUDED
|
||||
|
||||
/**
|
||||
@file include/mysql/service_rpl_transaction_write_set.h
|
||||
This service provides a function for plugins to get the write set of a given
|
||||
transaction.
|
||||
|
||||
SYNOPSIS
|
||||
get_transaction_write_set()
|
||||
This service is used to fetch the write_set extracted for the currently
|
||||
executing transaction by passing the thread_id as an input parameter for
|
||||
the method.
|
||||
|
||||
@param [in] - thread_id - It is the thread identifier of the currently
|
||||
executing thread.
|
||||
|
||||
In the current implementation it is being called during RUN_HOOK macro,
|
||||
on which we know that thread is on plugin context.
|
||||
|
||||
Cleanup :
|
||||
The service caller must take of the memory allocated during the service
|
||||
call to prevent memory leaks.
|
||||
*/
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
This structure is used to keep the list of the hash values of the records
|
||||
changed in the transaction.
|
||||
*/
|
||||
struct st_trans_write_set
|
||||
{
|
||||
unsigned int m_flags; // reserved
|
||||
unsigned long write_set_size; // Size of the PKE set of the transaction.
|
||||
unsigned long long* write_set; // A pointer to the PKE set.
|
||||
};
|
||||
typedef struct st_trans_write_set Transaction_write_set;
|
||||
|
||||
extern struct transaction_write_set_service_st {
|
||||
Transaction_write_set* (*get_transaction_write_set)(unsigned long m_thread_id);
|
||||
void (*require_full_write_set)(int requires_ws);
|
||||
void (*set_write_set_memory_size_limit)(long long size_limit);
|
||||
void (*update_write_set_memory_size_limit)(long long size_limit);
|
||||
} *transaction_write_set_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define get_transaction_write_set(m_thread_id) \
|
||||
(transaction_write_set_service->get_transaction_write_set((m_thread_id)))
|
||||
#define require_full_write_set(requires_ws) \
|
||||
transaction_write_set_service->require_full_write_set(requires_ws)
|
||||
#define set_write_set_memory_size_limit(size_limit) \
|
||||
transaction_write_set_service->set_write_set_memory_size_limit(size_limit)
|
||||
#define update_write_set_memory_size_limit(size_limit) \
|
||||
transaction_write_set_service->update_write_set_memory_size_limit(size_limit)
|
||||
|
||||
#else
|
||||
|
||||
Transaction_write_set* get_transaction_write_set(unsigned long m_thread_id);
|
||||
|
||||
void require_full_write_set(int requires_ws);
|
||||
|
||||
void set_write_set_memory_size_limit(long long size_limit);
|
||||
|
||||
void update_write_set_memory_size_limit(long long size_limit);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#define MYSQL_SERVICE_TRANSACTION_WRITE_SET_INCLUDED
|
||||
#endif
|
|
@ -0,0 +1,198 @@
|
|||
#ifdef __cplusplus
|
||||
#ifndef SERVICE_RULES_TABLE_INCLUDED
|
||||
#define SERVICE_RULES_TABLE_INCLUDED
|
||||
|
||||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#include <my_global.h>
|
||||
#include <my_dbug.h>
|
||||
#include <string>
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
@file service_rules_table.h
|
||||
|
||||
Plugin service that provides access to the rewrite rules table that is used
|
||||
by the Rewriter plugin. No other use intended.
|
||||
*/
|
||||
|
||||
class THD;
|
||||
struct TABLE_LIST;
|
||||
class Field;
|
||||
|
||||
namespace rules_table_service
|
||||
{
|
||||
|
||||
|
||||
/**
|
||||
There must be one function of this kind in order for the symbols in the
|
||||
server's dynamic library to be visible to plugins.
|
||||
*/
|
||||
int dummy_function_to_ensure_we_are_linked_into_the_server();
|
||||
|
||||
|
||||
/**
|
||||
Frees a const char pointer allocated in the server's dynamic library using
|
||||
new[].
|
||||
*/
|
||||
void free_string(const char *str);
|
||||
|
||||
|
||||
/**
|
||||
Writable cursor that allows reading and updating of rows in a persistent
|
||||
table.
|
||||
*/
|
||||
class Cursor
|
||||
{
|
||||
public:
|
||||
typedef int column_id;
|
||||
|
||||
static const column_id ILLEGAL_COLUMN_ID= -1;
|
||||
|
||||
/**
|
||||
Creates a cursor to an already-opened table. The constructor is kept
|
||||
explicit because of implicit conversions from void*.
|
||||
*/
|
||||
explicit Cursor(THD *thd);
|
||||
|
||||
/// Creates a past-the-end cursor.
|
||||
Cursor() :
|
||||
m_thd(NULL), m_table_list(NULL), m_is_finished(true)
|
||||
{}
|
||||
|
||||
column_id pattern_column() const { return m_pattern_column; }
|
||||
column_id pattern_database_column() const
|
||||
{
|
||||
return m_pattern_database_column;
|
||||
}
|
||||
column_id replacement_column() const { return m_replacement_column; }
|
||||
column_id enabled_column() const { return m_enabled_column; }
|
||||
column_id message_column() const { return m_message_column; }
|
||||
column_id pattern_digest_column() const { return m_pattern_digest_column; }
|
||||
column_id normalized_pattern_column() const {
|
||||
return m_normalized_pattern_column;
|
||||
}
|
||||
|
||||
/**
|
||||
True if the table does not contain columns named 'pattern', 'replacement',
|
||||
'enabled' and 'message'. In this case the cursor is equal to any
|
||||
past-the-end Cursor.
|
||||
*/
|
||||
bool table_is_malformed() { return m_table_is_malformed; }
|
||||
|
||||
/**
|
||||
Fetches the value of the column with the given number as a C string.
|
||||
|
||||
This interface is meant for crossing dynamic library boundaries, hence the
|
||||
use of C-style const char*. The function casts a column value to a C
|
||||
string and returns a copy, allocated in the callee's DL. The pointer
|
||||
must be freed using free_string().
|
||||
|
||||
@param fieldno One of PATTERN_COLUMN, REPLACEMENT_COLUMN, ENABLED_COLUMN
|
||||
or MESSAGE_COLUMN.
|
||||
*/
|
||||
const char *fetch_string(int fieldno);
|
||||
|
||||
/**
|
||||
Equality operator. The only cursors that are equal are past-the-end
|
||||
cursors.
|
||||
*/
|
||||
bool operator== (const Cursor &other)
|
||||
{
|
||||
return (m_is_finished == other.m_is_finished);
|
||||
}
|
||||
|
||||
/**
|
||||
Inequality operator. All cursors are considered different except
|
||||
past-the-end cursors.
|
||||
*/
|
||||
bool operator!= (const Cursor &other) { return !(*this == other); }
|
||||
|
||||
/**
|
||||
Advances this Cursor. Read errors are kept, and had_serious_read_error()
|
||||
will tell if there was an unexpected error (e.g. not EOF) while reading.
|
||||
*/
|
||||
Cursor &operator++ ()
|
||||
{
|
||||
if (!m_is_finished)
|
||||
read();
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// Prepares the write buffer for updating the current row.
|
||||
void make_writeable();
|
||||
|
||||
/**
|
||||
Sets the value of column colno to a string value.
|
||||
|
||||
@param colno The column number.
|
||||
@param str The string.
|
||||
@param length The string's length.
|
||||
*/
|
||||
void set(int colno, const char* str, size_t length);
|
||||
|
||||
/// Writes the row in the write buffer to the table at the current row.
|
||||
int write();
|
||||
|
||||
/// True if there was an unexpected error while reading, e.g. other than EOF.
|
||||
bool had_serious_read_error() const;
|
||||
|
||||
/// Closes the table scan if initiated and commits the transaction.
|
||||
~Cursor();
|
||||
|
||||
private:
|
||||
int field_index(const char *field_name);
|
||||
|
||||
int m_pattern_column;
|
||||
int m_pattern_database_column;
|
||||
int m_replacement_column;
|
||||
int m_enabled_column;
|
||||
int m_message_column;
|
||||
int m_pattern_digest_column;
|
||||
int m_normalized_pattern_column;
|
||||
|
||||
THD *m_thd;
|
||||
TABLE_LIST *m_table_list;
|
||||
|
||||
bool m_is_finished;
|
||||
bool m_table_is_malformed;
|
||||
int m_last_read_status;
|
||||
|
||||
int read();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
A past-the-end Cursor. All past-the-end cursors are considered equal
|
||||
when compared with operator ==.
|
||||
*/
|
||||
Cursor end();
|
||||
|
||||
}
|
||||
|
||||
#endif // SERVICE_RULES_TABLE_INCLUDED
|
||||
#endif // __cplusplus
|
|
@ -0,0 +1,102 @@
|
|||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_SECURITY_CONTEXT
|
||||
#define MYSQL_SERVICE_SECURITY_CONTEXT
|
||||
|
||||
/**
|
||||
@file include/mysql/service_security_context.h
|
||||
|
||||
This service provides functions for plugins and storage engines to
|
||||
manipulate the thread's security context.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
class Security_context;
|
||||
#define MYSQL_SECURITY_CONTEXT Security_context*
|
||||
#else
|
||||
#define MYSQL_SECURITY_CONTEXT void*
|
||||
#endif
|
||||
typedef char my_svc_bool;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern struct security_context_service_st {
|
||||
my_svc_bool (*thd_get_security_context)(MYSQL_THD, MYSQL_SECURITY_CONTEXT *out_ctx);
|
||||
my_svc_bool (*thd_set_security_context)(MYSQL_THD, MYSQL_SECURITY_CONTEXT in_ctx);
|
||||
|
||||
my_svc_bool (*security_context_create)(MYSQL_SECURITY_CONTEXT *out_ctx);
|
||||
my_svc_bool (*security_context_destroy)(MYSQL_SECURITY_CONTEXT);
|
||||
my_svc_bool (*security_context_copy)(MYSQL_SECURITY_CONTEXT in_ctx, MYSQL_SECURITY_CONTEXT *out_ctx);
|
||||
|
||||
my_svc_bool (*security_context_lookup)(MYSQL_SECURITY_CONTEXT ctx,
|
||||
const char *user, const char *host,
|
||||
const char *ip, const char *db);
|
||||
|
||||
my_svc_bool (*security_context_get_option)(MYSQL_SECURITY_CONTEXT, const char *name, void *inout_pvalue);
|
||||
my_svc_bool (*security_context_set_option)(MYSQL_SECURITY_CONTEXT, const char *name, void *pvalue);
|
||||
} *security_context_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define thd_get_security_context(_THD, _CTX) \
|
||||
security_context_service->thd_get_security_context(_THD, _CTX)
|
||||
#define thd_set_security_context(_THD, _CTX) \
|
||||
security_context_service->thd_set_security_context(_THD, _CTX)
|
||||
|
||||
#define security_context_create(_CTX) \
|
||||
security_context_service->security_context_create(_CTX)
|
||||
#define security_context_destroy(_CTX) \
|
||||
security_context_service->security_context_destroy(_CTX)
|
||||
#define security_context_copy(_CTX1, _CTX2) \
|
||||
security_context_service->security_context_copy(_CTX1,_CTX2)
|
||||
|
||||
#define security_context_lookup(_CTX, _U, _H, _IP, _DB) \
|
||||
security_context_service->security_context_lookup(_CTX, _U, _H, _IP, _DB)
|
||||
|
||||
#define security_context_get_option(_SEC_CTX, _NAME, _VALUE) \
|
||||
security_context_service->security_context_get_option(_SEC_CTX, _NAME, _VALUE)
|
||||
#define security_context_set_option(_SEC_CTX, _NAME, _VALUE) \
|
||||
security_context_service->security_context_set_option(_SEC_CTX, _NAME, _VALUE)
|
||||
#else
|
||||
my_svc_bool thd_get_security_context(MYSQL_THD, MYSQL_SECURITY_CONTEXT *out_ctx);
|
||||
my_svc_bool thd_set_security_context(MYSQL_THD, MYSQL_SECURITY_CONTEXT in_ctx);
|
||||
|
||||
my_svc_bool security_context_create(MYSQL_SECURITY_CONTEXT *out_ctx);
|
||||
my_svc_bool security_context_destroy(MYSQL_SECURITY_CONTEXT ctx);
|
||||
my_svc_bool security_context_copy(MYSQL_SECURITY_CONTEXT in_ctx, MYSQL_SECURITY_CONTEXT *out_ctx);
|
||||
|
||||
my_svc_bool security_context_lookup(MYSQL_SECURITY_CONTEXT ctx,
|
||||
const char *user, const char *host,
|
||||
const char *ip, const char *db);
|
||||
|
||||
my_svc_bool security_context_get_option(MYSQL_SECURITY_CONTEXT, const char *name, void *inout_pvalue);
|
||||
my_svc_bool security_context_set_option(MYSQL_SECURITY_CONTEXT, const char *name, void *pvalue);
|
||||
#endif /* !MYSQL_DYNAMIC_PLUGIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* _cplusplus */
|
||||
|
||||
#endif /* !MYSQL_SERVICE_SECURITY_CONTEXT */
|
|
@ -0,0 +1,179 @@
|
|||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
#ifndef MYSQL_SRV_SESSION_SERVICE_INCLUDED
|
||||
#define MYSQL_SRV_SESSION_SERVICE_INCLUDED
|
||||
|
||||
/**
|
||||
@file
|
||||
Header file for the Server session service. This service is to provide
|
||||
of creating sessions with the server. These sessions can be furtherly used
|
||||
together with the Command service to execute commands in the server.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
class Srv_session;
|
||||
typedef class Srv_session* MYSQL_SESSION;
|
||||
#else
|
||||
struct Srv_session;
|
||||
typedef struct Srv_session* MYSQL_SESSION;
|
||||
#endif
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include "mysql/plugin.h" /* MYSQL_THD */
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void (*srv_session_error_cb)(void *ctx,
|
||||
unsigned int sql_errno,
|
||||
const char *err_msg);
|
||||
|
||||
extern struct srv_session_service_st
|
||||
{
|
||||
int (*init_session_thread)(const void *plugin);
|
||||
|
||||
void (*deinit_session_thread)();
|
||||
|
||||
MYSQL_SESSION (*open_session)(srv_session_error_cb error_cb,
|
||||
void *plugix_ctx);
|
||||
|
||||
int (*detach_session)(MYSQL_SESSION session);
|
||||
|
||||
int (*close_session)(MYSQL_SESSION session);
|
||||
|
||||
int (*server_is_available)();
|
||||
} *srv_session_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define srv_session_init_thread(plugin) \
|
||||
srv_session_service->init_session_thread((plugin))
|
||||
|
||||
#define srv_session_deinit_thread() \
|
||||
srv_session_service->deinit_session_thread()
|
||||
|
||||
#define srv_session_open(cb, ctx) \
|
||||
srv_session_service->open_session((cb), (ctx))
|
||||
|
||||
#define srv_session_detach(session) \
|
||||
srv_session_service->detach_session((session))
|
||||
|
||||
#define srv_session_close(session) \
|
||||
srv_session_service->close_session((session))
|
||||
|
||||
#define srv_session_server_is_available() \
|
||||
srv_session_service->server_is_available()
|
||||
|
||||
#else
|
||||
|
||||
/**
|
||||
Initializes the current physical thread to use with session service.
|
||||
|
||||
Call this function ONLY in physical threads which are not initialized in
|
||||
any way by the server.
|
||||
|
||||
@param plugin Pointer to the plugin structure, passed to the plugin over
|
||||
the plugin init function.
|
||||
|
||||
@return
|
||||
0 success
|
||||
1 failure
|
||||
*/
|
||||
int srv_session_init_thread(const void *plugin);
|
||||
|
||||
/**
|
||||
Deinitializes the current physical thread to use with session service.
|
||||
|
||||
|
||||
Call this function ONLY in physical threads which were initialized using
|
||||
srv_session_init_thread().
|
||||
*/
|
||||
void srv_session_deinit_thread();
|
||||
|
||||
/**
|
||||
Opens a server session.
|
||||
|
||||
In a thread not initialized by the server itself, this function should be
|
||||
called only after srv_session_init_thread() has already been called.
|
||||
|
||||
@param error_cb Default completion callback
|
||||
@param plugin_ctx Plugin's context, opaque pointer that would
|
||||
be provided to callbacks. Might be NULL.
|
||||
@return
|
||||
session on success
|
||||
NULL on failure
|
||||
*/
|
||||
MYSQL_SESSION srv_session_open(srv_session_error_cb cb, void *plugix_ctx);
|
||||
|
||||
/**
|
||||
Detaches a session from current physical thread.
|
||||
|
||||
Detaches a previously attached session. Sessions are automatically attached
|
||||
when they are used with the Command service (command_service_run_command()).
|
||||
If the session is opened in a spawned thread, then it will stay attached
|
||||
after command_service_run_command() until another session is used in the
|
||||
same physical thread. The command services will detach the previously used
|
||||
session and attach the one to be used for execution.
|
||||
|
||||
This function should be called in case the session has to be used in
|
||||
different physical thread. It will unbound the session from the current
|
||||
physical thread. After that the session can be used in a different thread.
|
||||
|
||||
@param session Session to detach
|
||||
|
||||
@returns
|
||||
0 success
|
||||
1 failure
|
||||
*/
|
||||
int srv_session_detach(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Closes a previously opened session.
|
||||
|
||||
@param session Session to close
|
||||
|
||||
@return
|
||||
0 success
|
||||
1 failure
|
||||
*/
|
||||
int srv_session_close(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Returns if the server is available (not booting or shutting down)
|
||||
|
||||
@return
|
||||
0 not available
|
||||
1 available
|
||||
*/
|
||||
int srv_session_server_is_available();
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MYSQL_SRV_SESSION_SERVICE_INCLUDED */
|
|
@ -0,0 +1,180 @@
|
|||
#ifndef MYSQL_SERVICE_SRV_SESSION_INFO_INCLUDED
|
||||
#define MYSQL_SERVICE_SRV_SESSION_INFO_INCLUDED
|
||||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file
|
||||
Service providing setters and getters for some properties of a session
|
||||
*/
|
||||
|
||||
|
||||
#include "mysql/service_srv_session.h"
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include "my_thread.h" /* my_thread_id */
|
||||
#include "m_string.h" /* LEX_CSTRING */
|
||||
#include "plugin.h" /* MYSQL_THD */
|
||||
#include "mysql_com.h" /* Vio for violite.h */
|
||||
#include "violite.h" /* enum_vio_type */
|
||||
#include <stdint.h> /* uint16_t */
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern struct srv_session_info_service_st {
|
||||
MYSQL_THD (*get_thd)(MYSQL_SESSION session);
|
||||
|
||||
my_thread_id (*get_session_id)(MYSQL_SESSION session);
|
||||
|
||||
LEX_CSTRING (*get_current_db)(MYSQL_SESSION session);
|
||||
|
||||
uint16_t (*get_client_port)(MYSQL_SESSION session);
|
||||
int (*set_client_port)(MYSQL_SESSION session, uint16_t port);
|
||||
|
||||
int (*set_connection_type)(MYSQL_SESSION session, enum enum_vio_type type);
|
||||
|
||||
int (*killed)(MYSQL_SESSION session);
|
||||
|
||||
unsigned int (*session_count)();
|
||||
unsigned int (*thread_count)(const void *plugin);
|
||||
} *srv_session_info_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define srv_session_info_get_thd(session) srv_session_info_service->get_thd((session))
|
||||
#define srv_session_info_get_session_id(sess) srv_session_info_service->get_session_id((sess))
|
||||
#define srv_session_info_get_current_db(sess) srv_session_info_service->get_current_db((sess))
|
||||
#define srv_session_info_get_client_port(sess) srv_session_info_service->get_client_port((sess))
|
||||
#define srv_session_info_set_client_port(sess, port) srv_session_info_service->set_client_port((sess), (port))
|
||||
#define srv_session_info_set_connection_type(sess, type) srv_session_info_service->set_connection_type((sess), (type))
|
||||
#define srv_session_info_killed(sess) srv_session_info_service->killed((sess))
|
||||
#define srv_session_info_session_count(sess) srv_session_info_service->session_count(sess)
|
||||
#define srv_session_info_thread_count(plugin) srv_session_info_service->thread_count(plugin)
|
||||
|
||||
#else
|
||||
|
||||
/**
|
||||
Returns the THD of a session.
|
||||
|
||||
@param session Session
|
||||
|
||||
@returns
|
||||
address of the THD
|
||||
*/
|
||||
MYSQL_THD srv_session_info_get_thd(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Returns the ID of a session.
|
||||
|
||||
@param session Session
|
||||
*/
|
||||
my_thread_id srv_session_info_get_session_id(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Returns the current database of a session.
|
||||
|
||||
@note {NULL, 0} is returned case of no current database or session is NULL
|
||||
|
||||
|
||||
@param session Session
|
||||
*/
|
||||
LEX_CSTRING srv_session_info_get_current_db(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Returns the client port of a session.
|
||||
|
||||
@note The client port in SHOW PROCESSLIST, INFORMATION_SCHEMA.PROCESSLIST.
|
||||
This port is NOT shown in PERFORMANCE_SCHEMA.THREADS.
|
||||
|
||||
@param session Session
|
||||
*/
|
||||
uint16_t srv_session_info_get_client_port(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Sets the client port of a session.
|
||||
|
||||
@note The client port in SHOW PROCESSLIST, INFORMATION_SCHEMA.PROCESSLIST.
|
||||
This port is NOT shown in PERFORMANCE_SCHEMA.THREADS.
|
||||
|
||||
@param session Session
|
||||
@param port Port number
|
||||
|
||||
@return
|
||||
0 success
|
||||
1 failure
|
||||
*/
|
||||
int srv_session_info_set_client_port(MYSQL_SESSION session, uint16_t port);
|
||||
|
||||
/**
|
||||
Sets the connection type of a session.
|
||||
|
||||
@see enum_vio_type
|
||||
|
||||
@note The type is shown in PERFORMANCE_SCHEMA.THREADS. The value is translated
|
||||
from the enum to a string according to @see vio_type_names array
|
||||
in vio/vio.c
|
||||
|
||||
@note If NO_VIO_TYPE passed as type the call will fail.
|
||||
|
||||
@return
|
||||
0 success
|
||||
1 failure
|
||||
*/
|
||||
int srv_session_info_set_connection_type(MYSQL_SESSION session,
|
||||
enum enum_vio_type type);
|
||||
|
||||
/**
|
||||
Returns whether the session was killed
|
||||
|
||||
@param session Session
|
||||
|
||||
@return
|
||||
0 not killed
|
||||
1 killed
|
||||
*/
|
||||
int srv_session_info_killed(MYSQL_SESSION session);
|
||||
|
||||
/**
|
||||
Returns the number opened sessions in thread initialized by srv_session
|
||||
service.
|
||||
*/
|
||||
unsigned int srv_session_info_session_count();
|
||||
|
||||
|
||||
/**
|
||||
Returns the number opened sessions in thread initialized by srv_session
|
||||
service.
|
||||
|
||||
@param plugin Pointer to the plugin structure, passed to the plugin over
|
||||
the plugin init function.
|
||||
*/
|
||||
unsigned int srv_session_info_thread_count(const void *plugin);
|
||||
|
||||
#endif /* MYSQL_DYNAMIC_PLUGIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* MYSQL_SERVICE_SRV_SESSION_INFO_INCLUDED */
|
|
@ -0,0 +1,180 @@
|
|||
#ifndef SSL_WRAPPER_INCLUDED
|
||||
#define SSL_WRAPPER_INCLUDED
|
||||
|
||||
/* Copyright (c) 2016, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#include "violite.h"
|
||||
|
||||
namespace ssl_wrappe_service
|
||||
{
|
||||
|
||||
int MY_ATTRIBUTE((visibility("default")))
|
||||
dummy_function_to_ensure_we_are_linked_into_the_server();
|
||||
|
||||
} // ssl_wrappe_service
|
||||
|
||||
/**
|
||||
Return version of SSL used in currect connection
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
@param buffer Character buffer in which the version is going to be placed
|
||||
@param buffer_size Size of the character buffer
|
||||
*/
|
||||
extern "C"
|
||||
void ssl_wrapper_version(Vio *vio, char *version, const size_t version_size);
|
||||
|
||||
/**
|
||||
Return cipher used in current connection
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
@param buffer Character buffer in which the cipher name is going to be placed
|
||||
@param buffer_size Size of the character buffer
|
||||
*/
|
||||
extern "C"
|
||||
void ssl_wrapper_cipher(Vio *vio, char *cipher, const size_t cipher_size);
|
||||
|
||||
/**
|
||||
Return cipher list that can be used for SSL
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
@param clipher_list Pointer to an array of c-strings
|
||||
@param maximun_num_of_elements Size of the pointer array
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_cipher_list(Vio *vio, const char **clipher_list, const size_t maximun_num_of_elements);
|
||||
|
||||
/**
|
||||
Return the verification depth limit set in SSL
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
|
||||
@return
|
||||
-1 default values should be used
|
||||
>0 verification depth
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_verify_depth(Vio *vio);
|
||||
|
||||
/**
|
||||
Return the verification mode set in SSL
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
|
||||
@return
|
||||
-1 default values should be used
|
||||
>0 verification mode
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_verify_mode(Vio *vio);
|
||||
|
||||
/**
|
||||
Return issuer name form peers ssl certificate
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
@param issuer Character buffer in which the issuer name is going to be placed
|
||||
@param issuer_size Size of character buffer for the issuer name
|
||||
*/
|
||||
extern "C"
|
||||
void ssl_wrapper_get_peer_certificate_issuer(Vio *vio, char *issuer, const size_t issuer_size);
|
||||
|
||||
/**
|
||||
Return subject field form peers ssl certificate
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
@param subject Character buffer in which the subject is going to be placed
|
||||
@param subject_size Size of character buffer for the subject
|
||||
*/
|
||||
extern "C"
|
||||
void ssl_wrapper_get_peer_certificate_subject(Vio *vio, char *subject, const size_t subject_size);
|
||||
|
||||
/**
|
||||
Check is peer certificate is present and try to verify it
|
||||
|
||||
@param vio VIO connection descriptor
|
||||
|
||||
@return
|
||||
X509_V_OK verification of peer certificate succeeded
|
||||
-1 verification failed
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_get_verify_result_and_cert(Vio *vio);
|
||||
|
||||
/**
|
||||
Return the verification depth limit set in SSL context
|
||||
|
||||
@param vio_ssl VIO SSL contex descriptor
|
||||
|
||||
@return
|
||||
-1 default values should be used
|
||||
>0 verification depth
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_ctx_verify_depth(struct st_VioSSLFd *vio_ssl);
|
||||
|
||||
/**
|
||||
Return the verification mode set in SSL context
|
||||
|
||||
@param vio_ssl VIO SSL contex descriptor
|
||||
|
||||
@return
|
||||
-1 default values should be used
|
||||
>0 verification mode
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_ctx_verify_mode(struct st_VioSSLFd *vio_ssl);
|
||||
|
||||
/**
|
||||
Return the last day the server certificate is valid
|
||||
|
||||
@param vio_ssl VIO SSL contex descriptor
|
||||
@param no_after Character buffer for to be filed with the date in human readble format
|
||||
@param no_after_size Size of the character buffer
|
||||
*/
|
||||
extern "C"
|
||||
void ssl_wrapper_ctx_server_not_after(struct st_VioSSLFd *vio_ssl, char *no_after, const size_t no_after_size);
|
||||
|
||||
/**
|
||||
Return the first day the server certificate is valid
|
||||
|
||||
@param vio_ssl VIO SSL contex descriptor
|
||||
@param no_before Character buffer for to be filed with the date in human readble format
|
||||
@param no_before_size Size of the character buffer
|
||||
*/
|
||||
extern "C"
|
||||
void ssl_wrapper_ctx_server_not_before(struct st_VioSSLFd *vio_ssl, char *no_before, const size_t no_before_size);
|
||||
|
||||
extern "C"
|
||||
void ssl_wrapper_thread_cleanup();
|
||||
|
||||
extern "C"
|
||||
long ssl_wrapper_sess_accept(struct st_VioSSLFd *vio_ssl);
|
||||
|
||||
/**
|
||||
Cleanup data allocated by SSL on thread stack
|
||||
|
||||
*/
|
||||
extern "C"
|
||||
long ssl_wrapper_sess_accept_good(struct st_VioSSLFd *vio_ssl);
|
||||
|
||||
#endif /* SSL_WRAPPER_INCLUDED */
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
#ifndef MYSQL_SERVICE_THD_ALLOC_INCLUDED
|
||||
/* Copyright (c) 2009, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/**
|
||||
@file
|
||||
This service provdes functions to allocate memory in a connection local
|
||||
memory pool. The memory allocated there will be automatically freed at the
|
||||
end of the statement, don't use it for allocations that should live longer
|
||||
than that. For short living allocations this is more efficient than
|
||||
using my_malloc and friends, and automatic "garbage collection" allows not
|
||||
to think about memory leaks.
|
||||
|
||||
The pool is best for small to medium objects, don't use it for large
|
||||
allocations - they are better served with my_malloc.
|
||||
*/
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
class THD;
|
||||
#define MYSQL_THD THD*
|
||||
#else
|
||||
#define MYSQL_THD void*
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <mysql/mysql_lex_string.h>
|
||||
|
||||
extern struct thd_alloc_service_st {
|
||||
void *(*thd_alloc_func)(MYSQL_THD, size_t);
|
||||
void *(*thd_calloc_func)(MYSQL_THD, size_t);
|
||||
char *(*thd_strdup_func)(MYSQL_THD, const char *);
|
||||
char *(*thd_strmake_func)(MYSQL_THD, const char *, size_t);
|
||||
void *(*thd_memdup_func)(MYSQL_THD, const void*, size_t);
|
||||
MYSQL_LEX_STRING *(*thd_make_lex_string_func)(MYSQL_THD, MYSQL_LEX_STRING *,
|
||||
const char *, size_t, int);
|
||||
} *thd_alloc_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define thd_alloc(thd,size) (thd_alloc_service->thd_alloc_func((thd), (size)))
|
||||
|
||||
#define thd_calloc(thd,size) (thd_alloc_service->thd_calloc_func((thd), (size)))
|
||||
|
||||
#define thd_strdup(thd,str) (thd_alloc_service->thd_strdup_func((thd), (str)))
|
||||
|
||||
#define thd_strmake(thd,str,size) \
|
||||
(thd_alloc_service->thd_strmake_func((thd), (str), (size)))
|
||||
|
||||
#define thd_memdup(thd,str,size) \
|
||||
(thd_alloc_service->thd_memdup_func((thd), (str), (size)))
|
||||
|
||||
#define thd_make_lex_string(thd, lex_str, str, size, allocate_lex_string) \
|
||||
(thd_alloc_service->thd_make_lex_string_func((thd), (lex_str), (str), \
|
||||
(size), (allocate_lex_string)))
|
||||
|
||||
#else
|
||||
|
||||
/**
|
||||
Allocate memory in the connection's local memory pool
|
||||
|
||||
@details
|
||||
When properly used in place of @c my_malloc(), this can significantly
|
||||
improve concurrency. Don't use this or related functions to allocate
|
||||
large chunks of memory. Use for temporary storage only. The memory
|
||||
will be freed automatically at the end of the statement; no explicit
|
||||
code is required to prevent memory leaks.
|
||||
|
||||
@see alloc_root()
|
||||
*/
|
||||
void *thd_alloc(MYSQL_THD thd, size_t size);
|
||||
/**
|
||||
@see thd_alloc()
|
||||
*/
|
||||
void *thd_calloc(MYSQL_THD thd, size_t size);
|
||||
/**
|
||||
@see thd_alloc()
|
||||
*/
|
||||
char *thd_strdup(MYSQL_THD thd, const char *str);
|
||||
/**
|
||||
@see thd_alloc()
|
||||
*/
|
||||
char *thd_strmake(MYSQL_THD thd, const char *str, size_t size);
|
||||
/**
|
||||
@see thd_alloc()
|
||||
*/
|
||||
void *thd_memdup(MYSQL_THD thd, const void* str, size_t size);
|
||||
|
||||
/**
|
||||
Create a LEX_STRING in this connection's local memory pool
|
||||
|
||||
@param thd user thread connection handle
|
||||
@param lex_str pointer to LEX_STRING object to be initialized
|
||||
@param str initializer to be copied into lex_str
|
||||
@param size length of str, in bytes
|
||||
@param allocate_lex_string flag: if TRUE, allocate new LEX_STRING object,
|
||||
instead of using lex_str value
|
||||
@return NULL on failure, or pointer to the LEX_STRING object
|
||||
|
||||
@see thd_alloc()
|
||||
*/
|
||||
MYSQL_LEX_STRING *thd_make_lex_string(MYSQL_THD thd, MYSQL_LEX_STRING *lex_str,
|
||||
const char *str, size_t size,
|
||||
int allocate_lex_string);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#define MYSQL_SERVICE_THD_ALLOC_INCLUDED
|
||||
#endif
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
/* Copyright (c) 2015, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_THD_EGINE_LOCK_INCLUDED
|
||||
#define MYSQL_SERVICE_THD_EGINE_LOCK_INCLUDED
|
||||
|
||||
/**
|
||||
@file include/mysql/service_thd_engine_lock.h
|
||||
This service provides functions for storage engines to report
|
||||
lock related activities.
|
||||
|
||||
SYNOPSIS
|
||||
thd_row_lock_wait() - call it just when the engine find a transaction should wait
|
||||
another transaction to realease a row lock
|
||||
thd The session which is waiting for the row lock to release.
|
||||
thd_wait_for The session which is holding the row lock.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
class THD;
|
||||
#else
|
||||
#define THD void
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void thd_report_row_lock_wait(THD* self, THD *wait_for);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,121 @@
|
|||
/* Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SERVICE_THD_WAIT_INCLUDED
|
||||
#define MYSQL_SERVICE_THD_WAIT_INCLUDED
|
||||
|
||||
/**
|
||||
@file include/mysql/service_thd_wait.h
|
||||
This service provides functions for plugins and storage engines to report
|
||||
when they are going to sleep/stall.
|
||||
|
||||
SYNOPSIS
|
||||
thd_wait_begin() - call just before a wait begins
|
||||
thd Thread object
|
||||
Use NULL if the thd is NOT known.
|
||||
wait_type Type of wait
|
||||
1 -- short wait (e.g. for mutex)
|
||||
2 -- medium wait (e.g. for disk io)
|
||||
3 -- large wait (e.g. for locked row/table)
|
||||
NOTES
|
||||
This is used by the threadpool to have better knowledge of which
|
||||
threads that currently are actively running on CPUs. When a thread
|
||||
reports that it's going to sleep/stall, the threadpool scheduler is
|
||||
free to start another thread in the pool most likely. The expected wait
|
||||
time is simply an indication of how long the wait is expected to
|
||||
become, the real wait time could be very different.
|
||||
|
||||
thd_wait_end() called immediately after the wait is complete
|
||||
|
||||
thd_wait_end() MUST be called if thd_wait_begin() was called.
|
||||
|
||||
Using thd_wait_...() service is optional but recommended. Using it will
|
||||
improve performance as the thread pool will be more active at managing the
|
||||
thread workload.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
class THD;
|
||||
#define MYSQL_THD THD*
|
||||
#else
|
||||
#define MYSQL_THD void*
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
One should only report wait events that could potentially block for a
|
||||
long time. A mutex wait is too short of an event to report. The reason
|
||||
is that an event which is reported leads to a new thread starts
|
||||
executing a query and this has a negative impact of usage of CPU caches
|
||||
and thus the expected gain of starting a new thread must be higher than
|
||||
the expected cost of lost performance due to starting a new thread.
|
||||
|
||||
Good examples of events that should be reported are waiting for row locks
|
||||
that could easily be for many milliseconds or even seconds and the same
|
||||
holds true for global read locks, table locks and other meta data locks.
|
||||
Another event of interest is going to sleep for an extended time.
|
||||
|
||||
Note that user-level locks no longer use THD_WAIT_USER_LOCK wait type.
|
||||
Since their implementation relies on metadata locks manager it uses
|
||||
THD_WAIT_META_DATA_LOCK instead.
|
||||
*/
|
||||
typedef enum _thd_wait_type_e {
|
||||
THD_WAIT_SLEEP= 1,
|
||||
THD_WAIT_DISKIO= 2,
|
||||
THD_WAIT_ROW_LOCK= 3,
|
||||
THD_WAIT_GLOBAL_LOCK= 4,
|
||||
THD_WAIT_META_DATA_LOCK= 5,
|
||||
THD_WAIT_TABLE_LOCK= 6,
|
||||
THD_WAIT_USER_LOCK= 7,
|
||||
THD_WAIT_BINLOG= 8,
|
||||
THD_WAIT_GROUP_COMMIT= 9,
|
||||
THD_WAIT_SYNC= 10,
|
||||
THD_WAIT_LAST= 11
|
||||
} thd_wait_type;
|
||||
|
||||
extern struct thd_wait_service_st {
|
||||
void (*thd_wait_begin_func)(MYSQL_THD, int);
|
||||
void (*thd_wait_end_func)(MYSQL_THD);
|
||||
} *thd_wait_service;
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define thd_wait_begin(_THD, _WAIT_TYPE) \
|
||||
thd_wait_service->thd_wait_begin_func(_THD, _WAIT_TYPE)
|
||||
#define thd_wait_end(_THD) thd_wait_service->thd_wait_end_func(_THD)
|
||||
|
||||
#else
|
||||
|
||||
void thd_wait_begin(MYSQL_THD thd, int wait_type);
|
||||
void thd_wait_end(MYSQL_THD thd);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
/*
|
||||
Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef SERVICE_THREAD_SCHEDULER_INCLUDED
|
||||
#define SERVICE_THREAD_SCHEDULER_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct Connection_handler_functions;
|
||||
struct THD_event_functions;
|
||||
|
||||
extern struct my_thread_scheduler_service {
|
||||
int (*connection_handler_set)(struct Connection_handler_functions *,
|
||||
struct THD_event_functions *);
|
||||
int (*connection_handler_reset)();
|
||||
} *my_thread_scheduler_service;
|
||||
|
||||
|
||||
#ifdef MYSQL_DYNAMIC_PLUGIN
|
||||
|
||||
#define my_connection_handler_set(F, M) \
|
||||
my_thread_scheduler_service->connection_handler_set((F), (M))
|
||||
#define my_connection_handler_reset() \
|
||||
my_thread_scheduler_service->connection_handler_reset()
|
||||
|
||||
#else
|
||||
|
||||
/**
|
||||
Instantiates Plugin_connection_handler based on the supplied
|
||||
Conection_handler_functions and sets it as the current
|
||||
connection handler.
|
||||
|
||||
Also sets the THD_event_functions functions which will
|
||||
be called by the server when e.g. begining a wait.
|
||||
|
||||
Remembers the existing connection handler so that it can be restored later.
|
||||
|
||||
@param chf struct with functions to be called when e.g. handling
|
||||
new clients.
|
||||
@param tef struct with functions to be called when events
|
||||
(e.g. lock wait) happens.
|
||||
|
||||
@note Both pointers (i.e. not the structs themselves) will be copied,
|
||||
so the structs must not disappear.
|
||||
|
||||
@note We don't support dynamically loading more than one connection handler.
|
||||
|
||||
@retval 1 failure
|
||||
@retval 0 success
|
||||
*/
|
||||
int my_connection_handler_set(struct Connection_handler_functions *chf,
|
||||
struct THD_event_functions *tef);
|
||||
|
||||
/**
|
||||
Destroys the current connection handler and restores the previous.
|
||||
Should only be called after calling my_connection_handler_set().
|
||||
|
||||
@retval 1 failure
|
||||
@retval 0 success
|
||||
*/
|
||||
int my_connection_handler_reset();
|
||||
|
||||
#endif /* MYSQL_DYNAMIC_PLUGIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* SERVICE_THREAD_SCHEDULER_INCLUDED */
|
|
@ -0,0 +1,66 @@
|
|||
#ifndef MYSQL_SERVICES_INCLUDED
|
||||
/* Copyright (c) 2009, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
|
||||
/*
|
||||
Out of extern because of inclusion of files which include my_compiler.h
|
||||
which in turn complains about C-linkage of templates.
|
||||
service_srv_session.h and service_command.h use proper extern "C" for
|
||||
their exported symbols.
|
||||
*/
|
||||
#ifndef EMBEDDED_LIBRARY
|
||||
#include <mysql/service_srv_session.h>
|
||||
#include <mysql/service_srv_session_info.h>
|
||||
#include <mysql/service_command.h>
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <mysql/service_my_snprintf.h>
|
||||
#include <mysql/service_thd_alloc.h>
|
||||
#include <mysql/service_thd_wait.h>
|
||||
#include <mysql/service_thread_scheduler.h>
|
||||
#include <mysql/service_my_plugin_log.h>
|
||||
#include <mysql/service_mysql_string.h>
|
||||
#include <mysql/service_mysql_alloc.h>
|
||||
#include <mysql/service_mysql_password_policy.h>
|
||||
#include <mysql/service_parser.h>
|
||||
#include <mysql/service_rpl_transaction_ctx.h>
|
||||
#include <mysql/service_rpl_transaction_write_set.h>
|
||||
#include <mysql/service_security_context.h>
|
||||
#include <mysql/service_locking.h>
|
||||
#include <mysql/service_mysql_keyring.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#include <mysql/service_rules_table.h>
|
||||
#endif
|
||||
|
||||
#define MYSQL_SERVICES_INCLUDED
|
||||
#endif /* MYSQL_SERVICES_INCLUDED */
|
|
@ -0,0 +1,512 @@
|
|||
#include <mysql/service_srv_session.h>
|
||||
struct Srv_session;
|
||||
typedef struct Srv_session* MYSQL_SESSION;
|
||||
typedef void (*srv_session_error_cb)(void *ctx,
|
||||
unsigned int sql_errno,
|
||||
const char *err_msg);
|
||||
extern struct srv_session_service_st
|
||||
{
|
||||
int (*init_session_thread)(const void *plugin);
|
||||
void (*deinit_session_thread)();
|
||||
MYSQL_SESSION (*open_session)(srv_session_error_cb error_cb,
|
||||
void *plugix_ctx);
|
||||
int (*detach_session)(MYSQL_SESSION session);
|
||||
int (*close_session)(MYSQL_SESSION session);
|
||||
int (*server_is_available)();
|
||||
} *srv_session_service;
|
||||
int srv_session_init_thread(const void *plugin);
|
||||
void srv_session_deinit_thread();
|
||||
MYSQL_SESSION srv_session_open(srv_session_error_cb cb, void *plugix_ctx);
|
||||
int srv_session_detach(MYSQL_SESSION session);
|
||||
int srv_session_close(MYSQL_SESSION session);
|
||||
int srv_session_server_is_available();
|
||||
#include <mysql/service_srv_session_info.h>
|
||||
#include "mysql/service_srv_session.h"
|
||||
extern struct srv_session_info_service_st {
|
||||
MYSQL_THD (*get_thd)(MYSQL_SESSION session);
|
||||
my_thread_id (*get_session_id)(MYSQL_SESSION session);
|
||||
LEX_CSTRING (*get_current_db)(MYSQL_SESSION session);
|
||||
uint16_t (*get_client_port)(MYSQL_SESSION session);
|
||||
int (*set_client_port)(MYSQL_SESSION session, uint16_t port);
|
||||
int (*set_connection_type)(MYSQL_SESSION session, enum enum_vio_type type);
|
||||
int (*killed)(MYSQL_SESSION session);
|
||||
unsigned int (*session_count)();
|
||||
unsigned int (*thread_count)(const void *plugin);
|
||||
} *srv_session_info_service;
|
||||
MYSQL_THD srv_session_info_get_thd(MYSQL_SESSION session);
|
||||
my_thread_id srv_session_info_get_session_id(MYSQL_SESSION session);
|
||||
LEX_CSTRING srv_session_info_get_current_db(MYSQL_SESSION session);
|
||||
uint16_t srv_session_info_get_client_port(MYSQL_SESSION session);
|
||||
int srv_session_info_set_client_port(MYSQL_SESSION session, uint16_t port);
|
||||
int srv_session_info_set_connection_type(MYSQL_SESSION session,
|
||||
enum enum_vio_type type);
|
||||
int srv_session_info_killed(MYSQL_SESSION session);
|
||||
unsigned int srv_session_info_session_count();
|
||||
unsigned int srv_session_info_thread_count(const void *plugin);
|
||||
#include <mysql/service_command.h>
|
||||
#include "mysql/service_srv_session.h"
|
||||
#include "mysql/com_data.h"
|
||||
typedef struct st_com_init_db_data
|
||||
{
|
||||
const char *db_name;
|
||||
unsigned long length;
|
||||
} COM_INIT_DB_DATA;
|
||||
typedef struct st_com_refresh_data
|
||||
{
|
||||
unsigned char options;
|
||||
} COM_REFRESH_DATA;
|
||||
typedef struct st_com_shutdown_data
|
||||
{
|
||||
enum mysql_enum_shutdown_level level;
|
||||
} COM_SHUTDOWN_DATA;
|
||||
typedef struct st_com_kill_data
|
||||
{
|
||||
unsigned long id;
|
||||
} COM_KILL_DATA;
|
||||
typedef struct st_com_set_option_data
|
||||
{
|
||||
unsigned int opt_command;
|
||||
} COM_SET_OPTION_DATA;
|
||||
typedef struct st_com_stmt_execute_data
|
||||
{
|
||||
unsigned long stmt_id;
|
||||
unsigned long flags;
|
||||
unsigned char *params;
|
||||
unsigned long params_length;
|
||||
} COM_STMT_EXECUTE_DATA;
|
||||
typedef struct st_com_stmt_fetch_data
|
||||
{
|
||||
unsigned long stmt_id;
|
||||
unsigned long num_rows;
|
||||
} COM_STMT_FETCH_DATA;
|
||||
typedef struct st_com_stmt_send_long_data_data
|
||||
{
|
||||
unsigned long stmt_id;
|
||||
unsigned int param_number;
|
||||
unsigned char *longdata;
|
||||
unsigned long length;
|
||||
} COM_STMT_SEND_LONG_DATA_DATA;
|
||||
typedef struct st_com_stmt_prepare_data
|
||||
{
|
||||
const char *query;
|
||||
unsigned int length;
|
||||
} COM_STMT_PREPARE_DATA;
|
||||
typedef struct st_stmt_close_data
|
||||
{
|
||||
unsigned int stmt_id;
|
||||
} COM_STMT_CLOSE_DATA;
|
||||
typedef struct st_com_stmt_reset_data
|
||||
{
|
||||
unsigned int stmt_id;
|
||||
} COM_STMT_RESET_DATA;
|
||||
typedef struct st_com_query_data
|
||||
{
|
||||
const char *query;
|
||||
unsigned int length;
|
||||
} COM_QUERY_DATA;
|
||||
typedef struct st_com_field_list_data
|
||||
{
|
||||
unsigned char *table_name;
|
||||
unsigned int table_name_length;
|
||||
const unsigned char *query;
|
||||
unsigned int query_length;
|
||||
} COM_FIELD_LIST_DATA;
|
||||
union COM_DATA {
|
||||
COM_INIT_DB_DATA com_init_db;
|
||||
COM_REFRESH_DATA com_refresh;
|
||||
COM_SHUTDOWN_DATA com_shutdown;
|
||||
COM_KILL_DATA com_kill;
|
||||
COM_SET_OPTION_DATA com_set_option;
|
||||
COM_STMT_EXECUTE_DATA com_stmt_execute;
|
||||
COM_STMT_FETCH_DATA com_stmt_fetch;
|
||||
COM_STMT_SEND_LONG_DATA_DATA com_stmt_send_long_data;
|
||||
COM_STMT_PREPARE_DATA com_stmt_prepare;
|
||||
COM_STMT_CLOSE_DATA com_stmt_close;
|
||||
COM_STMT_RESET_DATA com_stmt_reset;
|
||||
COM_QUERY_DATA com_query;
|
||||
COM_FIELD_LIST_DATA com_field_list;
|
||||
};
|
||||
#include "mysql_time.h"
|
||||
enum enum_mysql_timestamp_type
|
||||
{
|
||||
MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
|
||||
MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
|
||||
};
|
||||
typedef struct st_mysql_time
|
||||
{
|
||||
unsigned int year, month, day, hour, minute, second;
|
||||
unsigned long second_part;
|
||||
my_bool neg;
|
||||
enum enum_mysql_timestamp_type time_type;
|
||||
} MYSQL_TIME;
|
||||
#include "decimal.h"
|
||||
typedef enum
|
||||
{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR}
|
||||
decimal_round_mode;
|
||||
typedef int32 decimal_digit_t;
|
||||
typedef struct st_decimal_t {
|
||||
int intg, frac, len;
|
||||
my_bool sign;
|
||||
decimal_digit_t *buf;
|
||||
} decimal_t;
|
||||
struct st_send_field
|
||||
{
|
||||
const char *db_name;
|
||||
const char *table_name;
|
||||
const char *org_table_name;
|
||||
const char *col_name;
|
||||
const char *org_col_name;
|
||||
unsigned long length;
|
||||
unsigned int charsetnr;
|
||||
unsigned int flags;
|
||||
unsigned int decimals;
|
||||
enum_field_types type;
|
||||
};
|
||||
struct st_command_service_cbs
|
||||
{
|
||||
int (*start_result_metadata)(void *ctx, uint num_cols, uint flags,
|
||||
const CHARSET_INFO *resultcs);
|
||||
int (*field_metadata)(void *ctx, struct st_send_field *field,
|
||||
const CHARSET_INFO *charset);
|
||||
int (*end_result_metadata)(void *ctx, uint server_status,
|
||||
uint warn_count);
|
||||
int (*start_row)(void *ctx);
|
||||
int (*end_row)(void *ctx);
|
||||
void (*abort_row)(void *ctx);
|
||||
ulong (*get_client_capabilities)(void *ctx);
|
||||
int (*get_null)(void * ctx);
|
||||
int (*get_integer)(void * ctx, longlong value);
|
||||
int (*get_longlong)(void * ctx, longlong value, uint is_unsigned);
|
||||
int (*get_decimal)(void * ctx, const decimal_t * value);
|
||||
int (*get_double)(void * ctx, double value, uint32_t decimals);
|
||||
int (*get_date)(void * ctx, const MYSQL_TIME * value);
|
||||
int (*get_time)(void * ctx, const MYSQL_TIME * value, uint decimals);
|
||||
int (*get_datetime)(void * ctx, const MYSQL_TIME * value, uint decimals);
|
||||
int (*get_string)(void * ctx, const char * value, size_t length,
|
||||
const CHARSET_INFO * valuecs);
|
||||
void (*handle_ok)(void * ctx,
|
||||
uint server_status, uint statement_warn_count,
|
||||
ulonglong affected_rows, ulonglong last_insert_id,
|
||||
const char * message);
|
||||
void (*handle_error)(void * ctx, uint sql_errno, const char * err_msg,
|
||||
const char * sqlstate);
|
||||
void (*shutdown)(void *ctx, int server_shutdown);
|
||||
};
|
||||
enum cs_text_or_binary
|
||||
{
|
||||
CS_TEXT_REPRESENTATION= 1,
|
||||
CS_BINARY_REPRESENTATION= 2,
|
||||
};
|
||||
extern struct command_service_st {
|
||||
int (*run_command)(MYSQL_SESSION session,
|
||||
enum enum_server_command command,
|
||||
const union COM_DATA * data,
|
||||
const CHARSET_INFO * client_cs,
|
||||
const struct st_command_service_cbs * callbacks,
|
||||
enum cs_text_or_binary text_or_binary,
|
||||
void * service_callbacks_ctx);
|
||||
} *command_service;
|
||||
int command_service_run_command(MYSQL_SESSION session,
|
||||
enum enum_server_command command,
|
||||
const union COM_DATA * data,
|
||||
const CHARSET_INFO * client_cs,
|
||||
const struct st_command_service_cbs * callbacks,
|
||||
enum cs_text_or_binary text_or_binary,
|
||||
void * service_callbacks_ctx);
|
||||
#include <mysql/service_my_snprintf.h>
|
||||
extern struct my_snprintf_service_st {
|
||||
size_t (*my_snprintf_type)(char*, size_t, const char*, ...);
|
||||
size_t (*my_vsnprintf_type)(char *, size_t, const char*, va_list);
|
||||
} *my_snprintf_service;
|
||||
size_t my_snprintf(char* to, size_t n, const char* fmt, ...);
|
||||
size_t my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap);
|
||||
#include <mysql/service_thd_alloc.h>
|
||||
#include <mysql/mysql_lex_string.h>
|
||||
struct st_mysql_lex_string
|
||||
{
|
||||
char *str;
|
||||
size_t length;
|
||||
};
|
||||
typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
|
||||
struct st_mysql_const_lex_string
|
||||
{
|
||||
const char *str;
|
||||
size_t length;
|
||||
};
|
||||
typedef struct st_mysql_const_lex_string MYSQL_LEX_CSTRING;
|
||||
extern struct thd_alloc_service_st {
|
||||
void *(*thd_alloc_func)(void*, size_t);
|
||||
void *(*thd_calloc_func)(void*, size_t);
|
||||
char *(*thd_strdup_func)(void*, const char *);
|
||||
char *(*thd_strmake_func)(void*, const char *, size_t);
|
||||
void *(*thd_memdup_func)(void*, const void*, size_t);
|
||||
MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
|
||||
const char *, size_t, int);
|
||||
} *thd_alloc_service;
|
||||
void *thd_alloc(void* thd, size_t size);
|
||||
void *thd_calloc(void* thd, size_t size);
|
||||
char *thd_strdup(void* thd, const char *str);
|
||||
char *thd_strmake(void* thd, const char *str, size_t size);
|
||||
void *thd_memdup(void* thd, const void* str, size_t size);
|
||||
MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
|
||||
const char *str, size_t size,
|
||||
int allocate_lex_string);
|
||||
#include <mysql/service_thd_wait.h>
|
||||
typedef enum _thd_wait_type_e {
|
||||
THD_WAIT_SLEEP= 1,
|
||||
THD_WAIT_DISKIO= 2,
|
||||
THD_WAIT_ROW_LOCK= 3,
|
||||
THD_WAIT_GLOBAL_LOCK= 4,
|
||||
THD_WAIT_META_DATA_LOCK= 5,
|
||||
THD_WAIT_TABLE_LOCK= 6,
|
||||
THD_WAIT_USER_LOCK= 7,
|
||||
THD_WAIT_BINLOG= 8,
|
||||
THD_WAIT_GROUP_COMMIT= 9,
|
||||
THD_WAIT_SYNC= 10,
|
||||
THD_WAIT_LAST= 11
|
||||
} thd_wait_type;
|
||||
extern struct thd_wait_service_st {
|
||||
void (*thd_wait_begin_func)(void*, int);
|
||||
void (*thd_wait_end_func)(void*);
|
||||
} *thd_wait_service;
|
||||
void thd_wait_begin(void* thd, int wait_type);
|
||||
void thd_wait_end(void* thd);
|
||||
#include <mysql/service_thread_scheduler.h>
|
||||
struct Connection_handler_functions;
|
||||
struct THD_event_functions;
|
||||
extern struct my_thread_scheduler_service {
|
||||
int (*connection_handler_set)(struct Connection_handler_functions *,
|
||||
struct THD_event_functions *);
|
||||
int (*connection_handler_reset)();
|
||||
} *my_thread_scheduler_service;
|
||||
int my_connection_handler_set(struct Connection_handler_functions *chf,
|
||||
struct THD_event_functions *tef);
|
||||
int my_connection_handler_reset();
|
||||
#include <mysql/service_my_plugin_log.h>
|
||||
enum plugin_log_level
|
||||
{
|
||||
MY_ERROR_LEVEL,
|
||||
MY_WARNING_LEVEL,
|
||||
MY_INFORMATION_LEVEL
|
||||
};
|
||||
extern struct my_plugin_log_service
|
||||
{
|
||||
int (*my_plugin_log_message)(MYSQL_PLUGIN *, enum plugin_log_level, const char *, ...);
|
||||
} *my_plugin_log_service;
|
||||
int my_plugin_log_message(MYSQL_PLUGIN *plugin, enum plugin_log_level level,
|
||||
const char *format, ...);
|
||||
#include <mysql/service_mysql_string.h>
|
||||
typedef void *mysql_string_iterator_handle;
|
||||
typedef void *mysql_string_handle;
|
||||
extern struct mysql_string_service_st {
|
||||
int (*mysql_string_convert_to_char_ptr_type)
|
||||
(mysql_string_handle, const char *, char *, unsigned int, int *);
|
||||
mysql_string_iterator_handle (*mysql_string_get_iterator_type)
|
||||
(mysql_string_handle);
|
||||
int (*mysql_string_iterator_next_type)(mysql_string_iterator_handle);
|
||||
int (*mysql_string_iterator_isupper_type)(mysql_string_iterator_handle);
|
||||
int (*mysql_string_iterator_islower_type)(mysql_string_iterator_handle);
|
||||
int (*mysql_string_iterator_isdigit_type)(mysql_string_iterator_handle);
|
||||
mysql_string_handle (*mysql_string_to_lowercase_type)(mysql_string_handle);
|
||||
void (*mysql_string_free_type)(mysql_string_handle);
|
||||
void (*mysql_string_iterator_free_type)(mysql_string_iterator_handle);
|
||||
} *mysql_string_service;
|
||||
int mysql_string_convert_to_char_ptr(mysql_string_handle string_handle,
|
||||
const char *charset_name, char *buffer,
|
||||
unsigned int buffer_size, int *error);
|
||||
mysql_string_iterator_handle mysql_string_get_iterator(mysql_string_handle
|
||||
string_handle);
|
||||
int mysql_string_iterator_next(mysql_string_iterator_handle iterator_handle);
|
||||
int mysql_string_iterator_isupper(mysql_string_iterator_handle iterator_handle);
|
||||
int mysql_string_iterator_islower(mysql_string_iterator_handle iterator_handle);
|
||||
int mysql_string_iterator_isdigit(mysql_string_iterator_handle iterator_handle);
|
||||
mysql_string_handle mysql_string_to_lowercase(mysql_string_handle
|
||||
string_handle);
|
||||
void mysql_string_free(mysql_string_handle);
|
||||
void mysql_string_iterator_free(mysql_string_iterator_handle);
|
||||
#include <mysql/service_mysql_alloc.h>
|
||||
#include "mysql/psi/psi_memory.h"
|
||||
#include "psi_base.h"
|
||||
struct PSI_thread;
|
||||
typedef unsigned int PSI_memory_key;
|
||||
typedef int myf_t;
|
||||
typedef void * (*mysql_malloc_t)(PSI_memory_key key, size_t size, myf_t flags);
|
||||
typedef void * (*mysql_realloc_t)(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
|
||||
typedef void (*mysql_claim_t)(void *ptr);
|
||||
typedef void (*mysql_free_t)(void *ptr);
|
||||
typedef void * (*my_memdup_t)(PSI_memory_key key, const void *from, size_t length, myf_t flags);
|
||||
typedef char * (*my_strdup_t)(PSI_memory_key key, const char *from, myf_t flags);
|
||||
typedef char * (*my_strndup_t)(PSI_memory_key key, const char *from, size_t length, myf_t flags);
|
||||
struct mysql_malloc_service_st
|
||||
{
|
||||
mysql_malloc_t mysql_malloc;
|
||||
mysql_realloc_t mysql_realloc;
|
||||
mysql_claim_t mysql_claim;
|
||||
mysql_free_t mysql_free;
|
||||
my_memdup_t my_memdup;
|
||||
my_strdup_t my_strdup;
|
||||
my_strndup_t my_strndup;
|
||||
};
|
||||
extern struct mysql_malloc_service_st *mysql_malloc_service;
|
||||
extern void * my_malloc(PSI_memory_key key, size_t size, myf_t flags);
|
||||
extern void * my_realloc(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
|
||||
extern void my_claim(void *ptr);
|
||||
extern void my_free(void *ptr);
|
||||
extern void * my_memdup(PSI_memory_key key, const void *from, size_t length, myf_t flags);
|
||||
extern char * my_strdup(PSI_memory_key key, const char *from, myf_t flags);
|
||||
extern char * my_strndup(PSI_memory_key key, const char *from, size_t length, myf_t flags);
|
||||
#include <mysql/service_mysql_password_policy.h>
|
||||
extern struct mysql_password_policy_service_st {
|
||||
int (*my_validate_password_policy_func)(const char *, unsigned int);
|
||||
int (*my_calculate_password_strength_func)(const char *, unsigned int);
|
||||
} *mysql_password_policy_service;
|
||||
int my_validate_password_policy(const char *, unsigned int);
|
||||
int my_calculate_password_strength(const char *, unsigned int);
|
||||
#include <mysql/service_parser.h>
|
||||
#include "my_md5_size.h"
|
||||
#include <mysql/mysql_lex_string.h>
|
||||
typedef void* MYSQL_ITEM;
|
||||
typedef
|
||||
int (*parse_node_visit_function)(MYSQL_ITEM item, unsigned char* arg);
|
||||
typedef
|
||||
int (*sql_condition_handler_function)(int sql_errno,
|
||||
const char* sqlstate,
|
||||
const char* msg,
|
||||
void *state);
|
||||
struct st_my_thread_handle;
|
||||
extern struct mysql_parser_service_st {
|
||||
void* (*mysql_current_session)();
|
||||
void* (*mysql_open_session)();
|
||||
void (*mysql_start_thread)(void* thd, void *(*callback_fun)(void*),
|
||||
void *arg,
|
||||
struct st_my_thread_handle *thread_handle);
|
||||
void (*mysql_join_thread)(struct st_my_thread_handle *thread_handle);
|
||||
void (*mysql_set_current_database)(void* thd, const MYSQL_LEX_STRING db);
|
||||
int (*mysql_parse)(void* thd, const MYSQL_LEX_STRING query,
|
||||
unsigned char is_prepared,
|
||||
sql_condition_handler_function handle_condition,
|
||||
void *condition_handler_state);
|
||||
int (*mysql_get_statement_type)(void* thd);
|
||||
int (*mysql_get_statement_digest)(void* thd, unsigned char *digest);
|
||||
int (*mysql_get_number_params)(void* thd);
|
||||
int (*mysql_extract_prepared_params)(void* thd, int *positions);
|
||||
int (*mysql_visit_tree)(void* thd, parse_node_visit_function processor,
|
||||
unsigned char* arg);
|
||||
MYSQL_LEX_STRING (*mysql_item_string)(MYSQL_ITEM item);
|
||||
void (*mysql_free_string)(MYSQL_LEX_STRING string);
|
||||
MYSQL_LEX_STRING (*mysql_get_query)(void* thd);
|
||||
MYSQL_LEX_STRING (*mysql_get_normalized_query)(void* thd);
|
||||
} *mysql_parser_service;
|
||||
typedef void *(*callback_function)(void*);
|
||||
void* mysql_parser_current_session();
|
||||
void* mysql_parser_open_session();
|
||||
void mysql_parser_start_thread(void* thd, callback_function fun, void *arg,
|
||||
struct st_my_thread_handle *thread_handle);
|
||||
void mysql_parser_join_thread(struct st_my_thread_handle *thread_handle);
|
||||
void mysql_parser_set_current_database(void* thd,
|
||||
const MYSQL_LEX_STRING db);
|
||||
int mysql_parser_parse(void* thd, const MYSQL_LEX_STRING query,
|
||||
unsigned char is_prepared,
|
||||
sql_condition_handler_function handle_condition,
|
||||
void *condition_handler_state);
|
||||
int mysql_parser_get_statement_type(void* thd);
|
||||
int mysql_parser_get_statement_digest(void* thd, unsigned char *digest);
|
||||
int mysql_parser_get_number_params(void* thd);
|
||||
int mysql_parser_extract_prepared_params(void* thd, int *positions);
|
||||
int mysql_parser_visit_tree(void* thd, parse_node_visit_function processor,
|
||||
unsigned char* arg);
|
||||
MYSQL_LEX_STRING mysql_parser_item_string(MYSQL_ITEM item);
|
||||
void mysql_parser_free_string(MYSQL_LEX_STRING string);
|
||||
MYSQL_LEX_STRING mysql_parser_get_query(void* thd);
|
||||
MYSQL_LEX_STRING mysql_parser_get_normalized_query(void* thd);
|
||||
#include <mysql/service_rpl_transaction_ctx.h>
|
||||
struct st_transaction_termination_ctx
|
||||
{
|
||||
unsigned long m_thread_id;
|
||||
unsigned int m_flags;
|
||||
char m_rollback_transaction;
|
||||
char m_generated_gtid;
|
||||
int m_sidno;
|
||||
long long int m_gno;
|
||||
};
|
||||
typedef struct st_transaction_termination_ctx Transaction_termination_ctx;
|
||||
extern struct rpl_transaction_ctx_service_st {
|
||||
int (*set_transaction_ctx)(Transaction_termination_ctx transaction_termination_ctx);
|
||||
} *rpl_transaction_ctx_service;
|
||||
int set_transaction_ctx(Transaction_termination_ctx transaction_termination_ctx);
|
||||
#include <mysql/service_rpl_transaction_write_set.h>
|
||||
struct st_trans_write_set
|
||||
{
|
||||
unsigned int m_flags;
|
||||
unsigned long write_set_size;
|
||||
unsigned long long* write_set;
|
||||
};
|
||||
typedef struct st_trans_write_set Transaction_write_set;
|
||||
extern struct transaction_write_set_service_st {
|
||||
Transaction_write_set* (*get_transaction_write_set)(unsigned long m_thread_id);
|
||||
void (*require_full_write_set)(int requires_ws);
|
||||
void (*set_write_set_memory_size_limit)(long long size_limit);
|
||||
void (*update_write_set_memory_size_limit)(long long size_limit);
|
||||
} *transaction_write_set_service;
|
||||
Transaction_write_set* get_transaction_write_set(unsigned long m_thread_id);
|
||||
void require_full_write_set(int requires_ws);
|
||||
void set_write_set_memory_size_limit(long long size_limit);
|
||||
void update_write_set_memory_size_limit(long long size_limit);
|
||||
#include <mysql/service_security_context.h>
|
||||
typedef char my_svc_bool;
|
||||
extern struct security_context_service_st {
|
||||
my_svc_bool (*thd_get_security_context)(void*, void* *out_ctx);
|
||||
my_svc_bool (*thd_set_security_context)(void*, void* in_ctx);
|
||||
my_svc_bool (*security_context_create)(void* *out_ctx);
|
||||
my_svc_bool (*security_context_destroy)(void*);
|
||||
my_svc_bool (*security_context_copy)(void* in_ctx, void* *out_ctx);
|
||||
my_svc_bool (*security_context_lookup)(void* ctx,
|
||||
const char *user, const char *host,
|
||||
const char *ip, const char *db);
|
||||
my_svc_bool (*security_context_get_option)(void*, const char *name, void *inout_pvalue);
|
||||
my_svc_bool (*security_context_set_option)(void*, const char *name, void *pvalue);
|
||||
} *security_context_service;
|
||||
my_svc_bool thd_get_security_context(void*, void* *out_ctx);
|
||||
my_svc_bool thd_set_security_context(void*, void* in_ctx);
|
||||
my_svc_bool security_context_create(void* *out_ctx);
|
||||
my_svc_bool security_context_destroy(void* ctx);
|
||||
my_svc_bool security_context_copy(void* in_ctx, void* *out_ctx);
|
||||
my_svc_bool security_context_lookup(void* ctx,
|
||||
const char *user, const char *host,
|
||||
const char *ip, const char *db);
|
||||
my_svc_bool security_context_get_option(void*, const char *name, void *inout_pvalue);
|
||||
my_svc_bool security_context_set_option(void*, const char *name, void *pvalue);
|
||||
#include <mysql/service_locking.h>
|
||||
enum enum_locking_service_lock_type
|
||||
{ LOCKING_SERVICE_READ, LOCKING_SERVICE_WRITE };
|
||||
extern struct mysql_locking_service_st {
|
||||
int (*mysql_acquire_locks)(void* opaque_thd, const char* lock_namespace,
|
||||
const char**lock_names, size_t lock_num,
|
||||
enum enum_locking_service_lock_type lock_type,
|
||||
unsigned long lock_timeout);
|
||||
int (*mysql_release_locks)(void* opaque_thd, const char* lock_namespace);
|
||||
} *mysql_locking_service;
|
||||
int mysql_acquire_locking_service_locks(void* opaque_thd,
|
||||
const char* lock_namespace,
|
||||
const char**lock_names,
|
||||
size_t lock_num,
|
||||
enum enum_locking_service_lock_type lock_type,
|
||||
unsigned long lock_timeout);
|
||||
int mysql_release_locking_service_locks(void* opaque_thd,
|
||||
const char* lock_namespace);
|
||||
#include <mysql/service_mysql_keyring.h>
|
||||
extern struct mysql_keyring_service_st
|
||||
{
|
||||
int (*my_key_store_func)(const char *, const char *, const char *,
|
||||
const void *, size_t);
|
||||
int (*my_key_fetch_func)(const char *, char **, const char *, void **,
|
||||
size_t *);
|
||||
int (*my_key_remove_func)(const char *, const char *);
|
||||
int (*my_key_generate_func)(const char *, const char *, const char *,
|
||||
size_t);
|
||||
} *mysql_keyring_service;
|
||||
int my_key_store(const char *, const char *, const char *, const void *, size_t);
|
||||
int my_key_fetch(const char *, char **, const char *, void **,
|
||||
size_t *);
|
||||
int my_key_remove(const char *, const char *);
|
||||
int my_key_generate(const char *, const char *, const char *, size_t);
|
|
@ -0,0 +1,192 @@
|
|||
/*
|
||||
Copyright (c) 2010, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef THREAD_POOL_PRIV_INCLUDED
|
||||
#define THREAD_POOL_PRIV_INCLUDED
|
||||
|
||||
/*
|
||||
The thread pool requires access to some MySQL server error codes, this is
|
||||
accessed from mysqld_error.h.
|
||||
We need access to the struct that defines the thread pool plugin interface
|
||||
which is accessed through scheduler.h.
|
||||
All accesses to THD variables and functions are defined in this header file.
|
||||
A thread pool can also use DEBUG_SYNC and must thus include
|
||||
debug_sync.h
|
||||
To handle definitions of Information Schema plugins it is also required
|
||||
to include sql_profile.h and table.h.
|
||||
*/
|
||||
#include <mysqld_error.h> /* To get ER_ERROR_ON_READ */
|
||||
#define MYSQL_SERVER 1
|
||||
#include <conn_handler/channel_info.h>
|
||||
#include <conn_handler/connection_handler_manager.h>
|
||||
#include <debug_sync.h>
|
||||
#include <sql_profile.h>
|
||||
#include <table.h>
|
||||
#include "field.h"
|
||||
#include "sql_thd_internal_api.h"
|
||||
#include <set>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
This structure must be populated by plugins which implement connection
|
||||
handlers and passed as an argument to my_connection_handler_set() in
|
||||
order to activate the connection handler.
|
||||
|
||||
The structure contains pointers to plugin functions which the server
|
||||
will call when a new client connects or when the connection handler is
|
||||
unloaded. It also containts the maximum number of threads the connection
|
||||
handler will create.
|
||||
*/
|
||||
struct Connection_handler_functions
|
||||
{
|
||||
/**
|
||||
The maximum number of threads this connection handler will create.
|
||||
*/
|
||||
uint max_threads;
|
||||
|
||||
/**
|
||||
Called by the server when a new client connects.
|
||||
|
||||
@param channel_info Pointer to object containing information
|
||||
about the new connection.
|
||||
|
||||
@retval true failure
|
||||
@retval false success
|
||||
*/
|
||||
bool (*add_connection)(Channel_info *channel_info);
|
||||
|
||||
/**
|
||||
Called by the server when the connection handler is destroyed.
|
||||
*/
|
||||
void (*end)(void);
|
||||
};
|
||||
|
||||
/* create thd from channel_info object */
|
||||
THD* create_thd(Channel_info* channel_info);
|
||||
/* destroy channel_info object */
|
||||
void destroy_channel_info(Channel_info* channel_info);
|
||||
/* Decrement connection counter */
|
||||
void dec_connection_count();
|
||||
/*
|
||||
thread_created is maintained by thread pool when activated since
|
||||
user threads are created by the thread pool (and also special
|
||||
threads to maintain the thread pool). This is done through
|
||||
inc_thread_created.
|
||||
*/
|
||||
void inc_thread_created();
|
||||
|
||||
void thd_lock_thread_count(THD *thd);
|
||||
void thd_unlock_thread_count(THD *thd);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
Interface to global thread list iterator functions.
|
||||
Executes a function with signature 'void f(THD*, uint64)' for all THDs.
|
||||
*/
|
||||
typedef void (do_thd_impl_uint64)(THD*, uint64);
|
||||
void do_for_all_thd(do_thd_impl_uint64, uint64);
|
||||
|
||||
/* Needed to get access to scheduler variables */
|
||||
void* thd_get_scheduler_data(THD *thd);
|
||||
void thd_set_scheduler_data(THD *thd, void *data);
|
||||
PSI_thread* thd_get_psi(THD *thd);
|
||||
void thd_set_psi(THD *thd, PSI_thread *psi);
|
||||
|
||||
/* Interface to THD variables and functions */
|
||||
void thd_set_killed(THD *thd);
|
||||
void thd_clear_errors(THD *thd);
|
||||
void thd_close_connection(THD *thd);
|
||||
THD *thd_get_current_thd();
|
||||
void thd_lock_data(THD *thd);
|
||||
void thd_unlock_data(THD *thd);
|
||||
bool thd_is_transaction_active(THD *thd);
|
||||
int thd_connection_has_data(THD *thd);
|
||||
void thd_set_net_read_write(THD *thd, uint val);
|
||||
uint thd_get_net_read_write(THD *thd);
|
||||
void thd_set_not_killable(THD *thd);
|
||||
ulong thd_get_net_wait_timeout(THD *thd);
|
||||
my_socket thd_get_fd(THD *thd);
|
||||
int thd_store_globals(THD* thd);
|
||||
|
||||
/* Print to the MySQL error log */
|
||||
void sql_print_error(const char *format, ...);
|
||||
void sql_print_warning(const char *format, ...);
|
||||
void sql_print_information(const char *format, ...);
|
||||
|
||||
/* Store a table record */
|
||||
bool schema_table_store_record(THD *thd, TABLE *table);
|
||||
|
||||
/*
|
||||
The thread pool must be able to execute statements using the connection
|
||||
state in THD object. This is the main objective of the thread pool to
|
||||
schedule the start of these commands.
|
||||
*/
|
||||
bool do_command(THD *thd);
|
||||
|
||||
/*
|
||||
The thread pool requires an interface to the connection logic in the
|
||||
MySQL Server since the thread pool will maintain the event logic on
|
||||
the TCP connection of the MySQL Server. Thus new connections, dropped
|
||||
connections will be discovered by the thread pool and it needs to
|
||||
ensure that the proper MySQL Server logic attached to these events is
|
||||
executed.
|
||||
*/
|
||||
/* Prepare connection as part of connection set-up */
|
||||
bool thd_prepare_connection(THD *thd);
|
||||
/* Release auditing before executing statement */
|
||||
void mysql_audit_release(THD *thd);
|
||||
/* Check if connection is still alive */
|
||||
bool thd_connection_alive(THD *thd);
|
||||
/* Close connection with possible error code */
|
||||
void close_connection(THD *thd, uint sql_errno,
|
||||
bool server_shutdown, bool generate_event);
|
||||
/* End the connection before closing it */
|
||||
void end_connection(THD *thd);
|
||||
/* Reset thread globals */
|
||||
void reset_thread_globals(THD *thd);
|
||||
|
||||
/*
|
||||
max_connections is needed to calculate the maximum number of threads
|
||||
that is allowed to be started by the thread pool. The method
|
||||
get_max_connections() gets reference to this variable.
|
||||
*/
|
||||
ulong get_max_connections(void);
|
||||
/*
|
||||
connection_attrib is the thread attributes for connection threads,
|
||||
the method get_connection_attrib provides a reference to these
|
||||
attributes.
|
||||
*/
|
||||
my_thread_attr_t *get_connection_attrib(void);
|
||||
|
||||
/* Increment the status variable 'Aborted_connects'. */
|
||||
#ifndef EMBEDDED_LIBRARY
|
||||
void increment_aborted_connects();
|
||||
#endif
|
||||
#endif // THREAD_POOL_PRIV_INCLUDED
|
|
@ -0,0 +1,51 @@
|
|||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
|
||||
|
||||
/* Defines to make different thread packages compatible */
|
||||
|
||||
#ifndef THREAD_TYPE_INCLUDED
|
||||
#define THREAD_TYPE_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
|
||||
/* Flags for the THD::system_thread variable */
|
||||
enum enum_thread_type
|
||||
{
|
||||
NON_SYSTEM_THREAD= 0,
|
||||
SYSTEM_THREAD_SLAVE_IO= 1,
|
||||
SYSTEM_THREAD_SLAVE_SQL= 2,
|
||||
SYSTEM_THREAD_NDBCLUSTER_BINLOG= 4,
|
||||
SYSTEM_THREAD_EVENT_SCHEDULER= 8,
|
||||
SYSTEM_THREAD_EVENT_WORKER= 16,
|
||||
SYSTEM_THREAD_INFO_REPOSITORY= 32,
|
||||
SYSTEM_THREAD_SLAVE_WORKER= 64,
|
||||
SYSTEM_THREAD_COMPRESS_GTID_TABLE= 128,
|
||||
SYSTEM_THREAD_BACKGROUND= 256
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* THREAD_TYPE_INCLUDED */
|
|
@ -1,90 +0,0 @@
|
|||
/* Copyright (c) 2017, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
Without limiting anything contained in the foregoing, this file,
|
||||
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
||||
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
||||
http://oss.oracle.com/licenses/universal-foss-exception.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef UDF_REGISTRATION_TYPES_H
|
||||
#define UDF_REGISTRATION_TYPES_H
|
||||
|
||||
#ifndef MYSQL_ABI_CHECK
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
/**
|
||||
Type of the user defined function return slot and arguments
|
||||
*/
|
||||
enum Item_result {
|
||||
INVALID_RESULT = -1, /** not valid for UDFs */
|
||||
STRING_RESULT = 0, /** char * */
|
||||
REAL_RESULT, /** double */
|
||||
INT_RESULT, /** long long */
|
||||
ROW_RESULT, /** not valid for UDFs */
|
||||
DECIMAL_RESULT /** char *, to be converted to/from a decimal */
|
||||
};
|
||||
|
||||
typedef struct UDF_ARGS {
|
||||
unsigned int arg_count; /**< Number of arguments */
|
||||
enum Item_result *arg_type; /**< Pointer to item_results */
|
||||
char **args; /**< Pointer to argument */
|
||||
unsigned long *lengths; /**< Length of string arguments */
|
||||
char *maybe_null; /**< Set to 1 for all maybe_null args */
|
||||
char **attributes; /**< Pointer to attribute name */
|
||||
unsigned long *attribute_lengths; /**< Length of attribute arguments */
|
||||
void *extension;
|
||||
} UDF_ARGS;
|
||||
|
||||
/**
|
||||
Information about the result of a user defined function
|
||||
|
||||
@todo add a notion for determinism of the UDF.
|
||||
|
||||
@sa Item_udf_func::update_used_tables()
|
||||
*/
|
||||
typedef struct UDF_INIT {
|
||||
bool maybe_null; /** 1 if function can return NULL */
|
||||
unsigned int decimals; /** for real functions */
|
||||
unsigned long max_length; /** For string functions */
|
||||
char *ptr; /** free pointer for function data */
|
||||
bool const_item; /** 1 if function always returns the same value */
|
||||
void *extension;
|
||||
} UDF_INIT;
|
||||
|
||||
enum Item_udftype { UDFTYPE_FUNCTION = 1, UDFTYPE_AGGREGATE };
|
||||
|
||||
typedef void (*Udf_func_clear)(UDF_INIT *, unsigned char *, unsigned char *);
|
||||
typedef void (*Udf_func_add)(UDF_INIT *, UDF_ARGS *, unsigned char *,
|
||||
unsigned char *);
|
||||
typedef void (*Udf_func_deinit)(UDF_INIT *);
|
||||
typedef bool (*Udf_func_init)(UDF_INIT *, UDF_ARGS *, char *);
|
||||
typedef void (*Udf_func_any)(void);
|
||||
typedef double (*Udf_func_double)(UDF_INIT *, UDF_ARGS *, unsigned char *,
|
||||
unsigned char *);
|
||||
typedef long long (*Udf_func_longlong)(UDF_INIT *, UDF_ARGS *, unsigned char *,
|
||||
unsigned char *);
|
||||
typedef char *(*Udf_func_string)(UDF_INIT *, UDF_ARGS *, char *,
|
||||
unsigned long *, unsigned char *,
|
||||
unsigned char *);
|
||||
|
||||
#endif /* UDF_REGISTRATION_TYPES_H */
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,48 @@
|
|||
/* Copyright (c) 2011, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/*
|
||||
Definitions private to the server,
|
||||
used in the networking layer to notify specific events.
|
||||
*/
|
||||
|
||||
#ifndef _mysql_com_server_h
|
||||
#define _mysql_com_server_h
|
||||
|
||||
struct st_net_server;
|
||||
|
||||
typedef void (*before_header_callback_fn)
|
||||
(struct st_net *net, void *user_data, size_t count);
|
||||
|
||||
typedef void (*after_header_callback_fn)
|
||||
(struct st_net *net, void *user_data, size_t count, my_bool rc);
|
||||
|
||||
struct st_net_server
|
||||
{
|
||||
before_header_callback_fn m_before_header;
|
||||
after_header_callback_fn m_after_header;
|
||||
void *m_user_data;
|
||||
};
|
||||
|
||||
typedef struct st_net_server NET_SERVER;
|
||||
|
||||
#endif
|
|
@ -0,0 +1,36 @@
|
|||
#ifndef MYSQL_EMBED_INCLUDED
|
||||
#define MYSQL_EMBED_INCLUDED
|
||||
|
||||
/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License, version 2.0,
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
This program is also distributed with certain software (including
|
||||
but not limited to OpenSSL) that is licensed under separate terms,
|
||||
as designated in a particular file or component or in included license
|
||||
documentation. The authors of MySQL hereby grant you an additional
|
||||
permission to link the program and your derivative works with the
|
||||
separately licensed software that they have included with MySQL.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License, version 2.0, for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
/* Defines that are unique to the embedded version of MySQL */
|
||||
|
||||
#ifdef EMBEDDED_LIBRARY
|
||||
|
||||
/* Things we don't need in the embedded version of MySQL */
|
||||
/* TODO HF add #undef HAVE_VIO if we don't want client in embedded library */
|
||||
|
||||
#undef HAVE_DLOPEN /* No udf functions */
|
||||
|
||||
#endif /* EMBEDDED_LIBRARY */
|
||||
#endif /* MYSQL_EMBED_INCLUDED */
|
|
@ -23,13 +23,12 @@
|
|||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
|
||||
|
||||
#ifndef _mysql_time_h_
|
||||
#define _mysql_time_h_
|
||||
|
||||
/**
|
||||
@file include/mysql_time.h
|
||||
/*
|
||||
Time declarations shared between the server and client API:
|
||||
you should not add anything to this header unless it's used
|
||||
(and hence should be visible) in mysql.h.
|
||||
|
@ -38,34 +37,13 @@
|
|||
and Time Values" chapter in documentation.
|
||||
*/
|
||||
|
||||
// Do not not pull in the server header "my_inttypes.h" from client code.
|
||||
// IWYU pragma: no_include "my_inttypes.h"
|
||||
|
||||
enum enum_mysql_timestamp_type {
|
||||
MYSQL_TIMESTAMP_NONE = -2,
|
||||
MYSQL_TIMESTAMP_ERROR = -1,
|
||||
|
||||
/// Stores year, month and day components.
|
||||
MYSQL_TIMESTAMP_DATE = 0,
|
||||
|
||||
/**
|
||||
Stores all date and time components.
|
||||
Value is in UTC for `TIMESTAMP` type.
|
||||
Value is in local time zone for `DATETIME` type.
|
||||
*/
|
||||
MYSQL_TIMESTAMP_DATETIME = 1,
|
||||
|
||||
/// Stores hour, minute, second and microsecond.
|
||||
MYSQL_TIMESTAMP_TIME = 2,
|
||||
|
||||
/**
|
||||
A temporary type for `DATETIME` or `TIMESTAMP` types equipped with time
|
||||
zone information. After the time zone information is reconciled, the type is
|
||||
converted to MYSQL_TIMESTAMP_DATETIME.
|
||||
*/
|
||||
MYSQL_TIMESTAMP_DATETIME_TZ = 3
|
||||
enum enum_mysql_timestamp_type
|
||||
{
|
||||
MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
|
||||
MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
Structure which is used to represent datetime values inside MySQL.
|
||||
|
||||
|
@ -78,13 +56,12 @@ enum enum_mysql_timestamp_type {
|
|||
value (time_type == MYSQL_TIMESTAMP_TIME) days and hour member can hold
|
||||
bigger values.
|
||||
*/
|
||||
typedef struct MYSQL_TIME {
|
||||
unsigned int year, month, day, hour, minute, second;
|
||||
unsigned long second_part; /**< microseconds */
|
||||
bool neg;
|
||||
typedef struct st_mysql_time
|
||||
{
|
||||
unsigned int year, month, day, hour, minute, second;
|
||||
unsigned long second_part; /**< microseconds */
|
||||
my_bool neg;
|
||||
enum enum_mysql_timestamp_type time_type;
|
||||
/// The time zone displacement, specified in seconds.
|
||||
int time_zone_displacement;
|
||||
} MYSQL_TIME;
|
||||
|
||||
#endif /* _mysql_time_h_ */
|
||||
|
|
|
@ -9,20 +9,19 @@
|
|||
#define _mysql_version_h
|
||||
|
||||
#define PROTOCOL_VERSION 10
|
||||
#define MYSQL_SERVER_VERSION "8.0.31"
|
||||
#define MYSQL_BASE_VERSION "mysqld-8.0"
|
||||
#define MYSQL_SERVER_VERSION "5.7.39"
|
||||
#define MYSQL_BASE_VERSION "mysqld-5.7"
|
||||
#define MYSQL_SERVER_SUFFIX_DEF ""
|
||||
#define MYSQL_VERSION_ID 80031
|
||||
#define FRM_VER 6
|
||||
#define MYSQL_VERSION_ID 50739
|
||||
#define MYSQL_PORT 3306
|
||||
#define MYSQL_ADMIN_PORT 33062
|
||||
#define MYSQL_PORT_DEFAULT 0
|
||||
#define MYSQL_UNIX_ADDR "/tmp/mysql.sock"
|
||||
#define MYSQL_CONFIG_NAME "my"
|
||||
#define MYSQL_PERSIST_CONFIG_NAME "mysqld-auto"
|
||||
#define MYSQL_COMPILATION_COMMENT "MySQL Community - GPL"
|
||||
#define MYSQL_COMPILATION_COMMENT_SERVER "MySQL Community Server - GPL"
|
||||
#define LIBMYSQL_VERSION "8.0.31"
|
||||
#define LIBMYSQL_VERSION_ID 80031
|
||||
#define MYSQL_COMPILATION_COMMENT "MySQL Community Server (GPL)"
|
||||
#define LIBMYSQL_VERSION "5.7.39"
|
||||
#define LIBMYSQL_VERSION_ID 50739
|
||||
#define SYS_SCHEMA_VERSION "1.5.2"
|
||||
|
||||
#ifndef LICENSE
|
||||
#define LICENSE GPL
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -11,7 +11,7 @@
|
|||
* documentation. The authors of MySQL hereby grant you an additional
|
||||
* permission to link the program and your derivative works with the
|
||||
* separately licensed software that they have included with MySQL.
|
||||
*
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
|
@ -19,81 +19,55 @@
|
|||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
||||
* 02110-1301 USA
|
||||
*/
|
||||
|
||||
/* Autogenerated file, please don't edit */
|
||||
|
||||
#include "mysqlx_error.h"
|
||||
|
||||
{"ER_X_BAD_MESSAGE", ER_X_BAD_MESSAGE, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITIES_PREPARE_FAILED", ER_X_CAPABILITIES_PREPARE_FAILED, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_NOT_FOUND", ER_X_CAPABILITY_NOT_FOUND, "", NULL, NULL, 0 },
|
||||
{"ER_X_INVALID_PROTOCOL_DATA", ER_X_INVALID_PROTOCOL_DATA, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_VALUE_LENGTH", ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_VALUE_LENGTH, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_KEY_LENGTH", ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_KEY_LENGTH, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_EMPTY_KEY", ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_EMPTY_KEY, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_LENGTH", ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_LENGTH, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_TYPE", ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_TYPE, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_SET_NOT_ALLOWED", ER_X_CAPABILITY_SET_NOT_ALLOWED, "", NULL, NULL, 0 },
|
||||
{"ER_X_SERVICE_ERROR", ER_X_SERVICE_ERROR, "", NULL, NULL, 0 },
|
||||
{"ER_X_SESSION", ER_X_SESSION, "", NULL, NULL, 0 },
|
||||
{"ER_X_INVALID_ARGUMENT", ER_X_INVALID_ARGUMENT, "", NULL, NULL, 0 },
|
||||
{"ER_X_MISSING_ARGUMENT", ER_X_MISSING_ARGUMENT, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_INSERT_DATA", ER_X_BAD_INSERT_DATA, "", NULL, NULL, 0 },
|
||||
{"ER_X_CMD_NUM_ARGUMENTS", ER_X_CMD_NUM_ARGUMENTS, "", NULL, NULL, 0 },
|
||||
{"ER_X_CMD_ARGUMENT_TYPE", ER_X_CMD_ARGUMENT_TYPE, "", NULL, NULL, 0 },
|
||||
{"ER_X_CMD_ARGUMENT_VALUE", ER_X_CMD_ARGUMENT_VALUE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_UPSERT_DATA", ER_X_BAD_UPSERT_DATA, "", NULL, NULL, 0 },
|
||||
{"ER_X_DUPLICATED_CAPABILITIES", ER_X_DUPLICATED_CAPABILITIES, "", NULL, NULL, 0 },
|
||||
{"ER_X_CMD_ARGUMENT_OBJECT_EMPTY", ER_X_CMD_ARGUMENT_OBJECT_EMPTY, "", NULL, NULL, 0 },
|
||||
{"ER_X_CMD_INVALID_ARGUMENT", ER_X_CMD_INVALID_ARGUMENT, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_UPDATE_DATA", ER_X_BAD_UPDATE_DATA, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_TYPE_OF_UPDATE", ER_X_BAD_TYPE_OF_UPDATE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_COLUMN_TO_UPDATE", ER_X_BAD_COLUMN_TO_UPDATE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_MEMBER_TO_UPDATE", ER_X_BAD_MEMBER_TO_UPDATE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_STATEMENT_ID", ER_X_BAD_STATEMENT_ID, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CURSOR_ID", ER_X_BAD_CURSOR_ID, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_SCHEMA", ER_X_BAD_SCHEMA, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_TABLE", ER_X_BAD_TABLE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_PROJECTION", ER_X_BAD_PROJECTION, "", NULL, NULL, 0 },
|
||||
{"ER_X_DOC_ID_MISSING", ER_X_DOC_ID_MISSING, "", NULL, NULL, 0 },
|
||||
{"ER_X_DUPLICATE_ENTRY", ER_X_DUPLICATE_ENTRY, "", NULL, NULL, 0 },
|
||||
{"ER_X_DOC_REQUIRED_FIELD_MISSING", ER_X_DOC_REQUIRED_FIELD_MISSING, "", NULL, NULL, 0 },
|
||||
{"ER_X_PROJ_BAD_KEY_NAME", ER_X_PROJ_BAD_KEY_NAME, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_DOC_PATH", ER_X_BAD_DOC_PATH, "", NULL, NULL, 0 },
|
||||
{"ER_X_CURSOR_EXISTS", ER_X_CURSOR_EXISTS, "", NULL, NULL, 0 },
|
||||
{"ER_X_CURSOR_REACHED_EOF", ER_X_CURSOR_REACHED_EOF, "", NULL, NULL, 0 },
|
||||
{"ER_X_PREPARED_STATMENT_CAN_HAVE_ONE_CURSOR", ER_X_PREPARED_STATMENT_CAN_HAVE_ONE_CURSOR, "", NULL, NULL, 0 },
|
||||
{"ER_X_PREPARED_EXECUTE_ARGUMENT_NOT_SUPPORTED", ER_X_PREPARED_EXECUTE_ARGUMENT_NOT_SUPPORTED, "", NULL, NULL, 0 },
|
||||
{"ER_X_PREPARED_EXECUTE_ARGUMENT_CONSISTENCY", ER_X_PREPARED_EXECUTE_ARGUMENT_CONSISTENCY, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPR_BAD_OPERATOR", ER_X_EXPR_BAD_OPERATOR, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPR_BAD_NUM_ARGS", ER_X_EXPR_BAD_NUM_ARGS, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPR_MISSING_ARG", ER_X_EXPR_MISSING_ARG, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPR_BAD_TYPE_VALUE", ER_X_EXPR_BAD_TYPE_VALUE, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPR_BAD_VALUE", ER_X_EXPR_BAD_VALUE, "", NULL, NULL, 0 },
|
||||
{"ER_X_INVALID_COLLECTION", ER_X_INVALID_COLLECTION, "", NULL, NULL, 0 },
|
||||
{"ER_X_INVALID_ADMIN_COMMAND", ER_X_INVALID_ADMIN_COMMAND, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPECT_NOT_OPEN", ER_X_EXPECT_NOT_OPEN, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPECT_NO_ERROR_FAILED", ER_X_EXPECT_NO_ERROR_FAILED, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPECT_BAD_CONDITION", ER_X_EXPECT_BAD_CONDITION, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPECT_BAD_CONDITION_VALUE", ER_X_EXPECT_BAD_CONDITION_VALUE, "", NULL, NULL, 0 },
|
||||
{"ER_X_INVALID_NAMESPACE", ER_X_INVALID_NAMESPACE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_NOTICE", ER_X_BAD_NOTICE, "", NULL, NULL, 0 },
|
||||
{"ER_X_CANNOT_DISABLE_NOTICE", ER_X_CANNOT_DISABLE_NOTICE, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_CONFIGURATION", ER_X_BAD_CONFIGURATION, "", NULL, NULL, 0 },
|
||||
{"ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS", ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS, "", NULL, NULL, 0 },
|
||||
{"ER_X_EXPECT_FIELD_EXISTS_FAILED", ER_X_EXPECT_FIELD_EXISTS_FAILED, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_LOCKING", ER_X_BAD_LOCKING, "", NULL, NULL, 0 },
|
||||
{"ER_X_FRAME_COMPRESSION_DISABLED", ER_X_FRAME_COMPRESSION_DISABLED, "", NULL, NULL, 0 },
|
||||
{"ER_X_DECOMPRESSION_FAILED", ER_X_DECOMPRESSION_FAILED, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_COMPRESSED_FRAME", ER_X_BAD_COMPRESSED_FRAME, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_COMPRESSION_INVALID_ALGORITHM", ER_X_CAPABILITY_COMPRESSION_INVALID_ALGORITHM, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_COMPRESSION_INVALID_SERVER_STYLE", ER_X_CAPABILITY_COMPRESSION_INVALID_SERVER_STYLE, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_COMPRESSION_INVALID_CLIENT_STYLE", ER_X_CAPABILITY_COMPRESSION_INVALID_CLIENT_STYLE, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_COMPRESSION_INVALID_OPTION", ER_X_CAPABILITY_COMPRESSION_INVALID_OPTION, "", NULL, NULL, 0 },
|
||||
{"ER_X_CAPABILITY_COMPRESSION_MISSING_REQUIRED_FIELDS", ER_X_CAPABILITY_COMPRESSION_MISSING_REQUIRED_FIELDS, "", NULL, NULL, 0 },
|
||||
{"ER_X_DOCUMENT_DOESNT_MATCH_EXPECTED_SCHEMA", ER_X_DOCUMENT_DOESNT_MATCH_EXPECTED_SCHEMA, "", NULL, NULL, 0 },
|
||||
{"ER_X_COLLECTION_OPTION_DOESNT_EXISTS", ER_X_COLLECTION_OPTION_DOESNT_EXISTS, "", NULL, NULL, 0 },
|
||||
{"ER_X_INVALID_VALIDATION_SCHEMA", ER_X_INVALID_VALIDATION_SCHEMA, "", NULL, NULL, 0 },
|
||||
{"ER_X_BAD_MESSAGE", ER_X_BAD_MESSAGE, ""},
|
||||
{"ER_X_CAPABILITIES_PREPARE_FAILED", ER_X_CAPABILITIES_PREPARE_FAILED, ""},
|
||||
{"ER_X_CAPABILITY_NOT_FOUND", ER_X_CAPABILITY_NOT_FOUND, ""},
|
||||
{"ER_X_INVALID_PROTOCOL_DATA", ER_X_INVALID_PROTOCOL_DATA, ""},
|
||||
{"ER_X_SERVICE_ERROR", ER_X_SERVICE_ERROR, ""},
|
||||
{"ER_X_SESSION", ER_X_SESSION, ""},
|
||||
{"ER_X_INVALID_ARGUMENT", ER_X_INVALID_ARGUMENT, ""},
|
||||
{"ER_X_MISSING_ARGUMENT", ER_X_MISSING_ARGUMENT, ""},
|
||||
{"ER_X_BAD_INSERT_DATA", ER_X_BAD_INSERT_DATA, ""},
|
||||
{"ER_X_CMD_NUM_ARGUMENTS", ER_X_CMD_NUM_ARGUMENTS, ""},
|
||||
{"ER_X_CMD_ARGUMENT_TYPE", ER_X_CMD_ARGUMENT_TYPE, ""},
|
||||
{"ER_X_CMD_ARGUMENT_VALUE", ER_X_CMD_ARGUMENT_VALUE, ""},
|
||||
{"ER_X_BAD_UPDATE_DATA", ER_X_BAD_UPDATE_DATA, ""},
|
||||
{"ER_X_BAD_TYPE_OF_UPDATE", ER_X_BAD_TYPE_OF_UPDATE, ""},
|
||||
{"ER_X_BAD_COLUMN_TO_UPDATE", ER_X_BAD_COLUMN_TO_UPDATE, ""},
|
||||
{"ER_X_BAD_MEMBER_TO_UPDATE", ER_X_BAD_MEMBER_TO_UPDATE, ""},
|
||||
{"ER_X_BAD_STATEMENT_ID", ER_X_BAD_STATEMENT_ID, ""},
|
||||
{"ER_X_BAD_CURSOR_ID", ER_X_BAD_CURSOR_ID, ""},
|
||||
{"ER_X_BAD_SCHEMA", ER_X_BAD_SCHEMA, ""},
|
||||
{"ER_X_BAD_TABLE", ER_X_BAD_TABLE, ""},
|
||||
{"ER_X_BAD_PROJECTION", ER_X_BAD_PROJECTION, ""},
|
||||
{"ER_X_DOC_ID_MISSING", ER_X_DOC_ID_MISSING, ""},
|
||||
{"ER_X_DOC_ID_DUPLICATE", ER_X_DOC_ID_DUPLICATE, ""},
|
||||
{"ER_X_DOC_REQUIRED_FIELD_MISSING", ER_X_DOC_REQUIRED_FIELD_MISSING, ""},
|
||||
{"ER_X_PROJ_BAD_KEY_NAME", ER_X_PROJ_BAD_KEY_NAME, ""},
|
||||
{"ER_X_BAD_DOC_PATH", ER_X_BAD_DOC_PATH, ""},
|
||||
{"ER_X_CURSOR_EXISTS", ER_X_CURSOR_EXISTS, ""},
|
||||
{"ER_X_EXPR_BAD_OPERATOR", ER_X_EXPR_BAD_OPERATOR, ""},
|
||||
{"ER_X_EXPR_BAD_NUM_ARGS", ER_X_EXPR_BAD_NUM_ARGS, ""},
|
||||
{"ER_X_EXPR_MISSING_ARG", ER_X_EXPR_MISSING_ARG, ""},
|
||||
{"ER_X_EXPR_BAD_TYPE_VALUE", ER_X_EXPR_BAD_TYPE_VALUE, ""},
|
||||
{"ER_X_EXPR_BAD_VALUE", ER_X_EXPR_BAD_VALUE, ""},
|
||||
{"ER_X_INVALID_COLLECTION", ER_X_INVALID_COLLECTION, ""},
|
||||
{"ER_X_INVALID_ADMIN_COMMAND", ER_X_INVALID_ADMIN_COMMAND, ""},
|
||||
{"ER_X_EXPECT_NOT_OPEN", ER_X_EXPECT_NOT_OPEN, ""},
|
||||
{"ER_X_EXPECT_FAILED", ER_X_EXPECT_FAILED, ""},
|
||||
{"ER_X_EXPECT_BAD_CONDITION", ER_X_EXPECT_BAD_CONDITION, ""},
|
||||
{"ER_X_EXPECT_BAD_CONDITION_VALUE", ER_X_EXPECT_BAD_CONDITION_VALUE, ""},
|
||||
{"ER_X_INVALID_NAMESPACE", ER_X_INVALID_NAMESPACE, ""},
|
||||
{"ER_X_BAD_NOTICE", ER_X_BAD_NOTICE, ""},
|
||||
{"ER_X_CANNOT_DISABLE_NOTICE", ER_X_CANNOT_DISABLE_NOTICE, ""},
|
||||
{"ER_X_BAD_CONFIGURATION", ER_X_BAD_CONFIGURATION, ""},
|
||||
{"ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS", ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS, ""},
|
||||
|
||||
|
|
|
@ -18,82 +18,55 @@
|
|||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
|
||||
#ifndef _MYSQLX_ERROR_H_
|
||||
#define _MYSQLX_ERROR_H_
|
||||
|
||||
#define ER_X_BAD_MESSAGE 5000
|
||||
#define ER_X_BAD_MESSAGE 5000
|
||||
#define ER_X_CAPABILITIES_PREPARE_FAILED 5001
|
||||
#define ER_X_CAPABILITY_NOT_FOUND 5002
|
||||
#define ER_X_INVALID_PROTOCOL_DATA 5003
|
||||
#define ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_VALUE_LENGTH 5004
|
||||
#define ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_KEY_LENGTH 5005
|
||||
#define ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_EMPTY_KEY 5006
|
||||
#define ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_LENGTH 5007
|
||||
#define ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_TYPE 5008
|
||||
#define ER_X_CAPABILITY_SET_NOT_ALLOWED 5009
|
||||
#define ER_X_SERVICE_ERROR 5010
|
||||
#define ER_X_SESSION 5011
|
||||
#define ER_X_INVALID_ARGUMENT 5012
|
||||
#define ER_X_MISSING_ARGUMENT 5013
|
||||
#define ER_X_BAD_INSERT_DATA 5014
|
||||
#define ER_X_CMD_NUM_ARGUMENTS 5015
|
||||
#define ER_X_CMD_ARGUMENT_TYPE 5016
|
||||
#define ER_X_CMD_ARGUMENT_VALUE 5017
|
||||
#define ER_X_BAD_UPSERT_DATA 5018
|
||||
#define ER_X_DUPLICATED_CAPABILITIES 5019
|
||||
#define ER_X_CMD_ARGUMENT_OBJECT_EMPTY 5020
|
||||
#define ER_X_CMD_INVALID_ARGUMENT 5021
|
||||
#define ER_X_BAD_UPDATE_DATA 5050
|
||||
#define ER_X_BAD_TYPE_OF_UPDATE 5051
|
||||
#define ER_X_BAD_COLUMN_TO_UPDATE 5052
|
||||
#define ER_X_BAD_MEMBER_TO_UPDATE 5053
|
||||
#define ER_X_BAD_STATEMENT_ID 5110
|
||||
#define ER_X_BAD_CURSOR_ID 5111
|
||||
#define ER_X_BAD_SCHEMA 5112
|
||||
#define ER_X_BAD_TABLE 5113
|
||||
#define ER_X_BAD_PROJECTION 5114
|
||||
#define ER_X_DOC_ID_MISSING 5115
|
||||
#define ER_X_DUPLICATE_ENTRY 5116
|
||||
#define ER_X_DOC_REQUIRED_FIELD_MISSING 5117
|
||||
#define ER_X_PROJ_BAD_KEY_NAME 5120
|
||||
#define ER_X_BAD_DOC_PATH 5121
|
||||
#define ER_X_CURSOR_EXISTS 5122
|
||||
#define ER_X_CURSOR_REACHED_EOF 5123
|
||||
#define ER_X_PREPARED_STATMENT_CAN_HAVE_ONE_CURSOR 5131
|
||||
#define ER_X_PREPARED_EXECUTE_ARGUMENT_NOT_SUPPORTED 5133
|
||||
#define ER_X_PREPARED_EXECUTE_ARGUMENT_CONSISTENCY 5134
|
||||
#define ER_X_EXPR_BAD_OPERATOR 5150
|
||||
#define ER_X_EXPR_BAD_NUM_ARGS 5151
|
||||
#define ER_X_EXPR_MISSING_ARG 5152
|
||||
#define ER_X_EXPR_BAD_TYPE_VALUE 5153
|
||||
#define ER_X_EXPR_BAD_VALUE 5154
|
||||
#define ER_X_INVALID_COLLECTION 5156
|
||||
#define ER_X_INVALID_ADMIN_COMMAND 5157
|
||||
#define ER_X_EXPECT_NOT_OPEN 5158
|
||||
#define ER_X_EXPECT_NO_ERROR_FAILED 5159
|
||||
#define ER_X_EXPECT_BAD_CONDITION 5160
|
||||
#define ER_X_EXPECT_BAD_CONDITION_VALUE 5161
|
||||
#define ER_X_INVALID_NAMESPACE 5162
|
||||
#define ER_X_BAD_NOTICE 5163
|
||||
#define ER_X_CANNOT_DISABLE_NOTICE 5164
|
||||
#define ER_X_BAD_CONFIGURATION 5165
|
||||
#define ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS 5167
|
||||
#define ER_X_EXPECT_FIELD_EXISTS_FAILED 5168
|
||||
#define ER_X_BAD_LOCKING 5169
|
||||
#define ER_X_FRAME_COMPRESSION_DISABLED 5170
|
||||
#define ER_X_DECOMPRESSION_FAILED 5171
|
||||
#define ER_X_BAD_COMPRESSED_FRAME 5174
|
||||
#define ER_X_CAPABILITY_COMPRESSION_INVALID_ALGORITHM 5175
|
||||
#define ER_X_CAPABILITY_COMPRESSION_INVALID_SERVER_STYLE 5176
|
||||
#define ER_X_CAPABILITY_COMPRESSION_INVALID_CLIENT_STYLE 5177
|
||||
#define ER_X_CAPABILITY_COMPRESSION_INVALID_OPTION 5178
|
||||
#define ER_X_CAPABILITY_COMPRESSION_MISSING_REQUIRED_FIELDS 5179
|
||||
#define ER_X_DOCUMENT_DOESNT_MATCH_EXPECTED_SCHEMA 5180
|
||||
#define ER_X_COLLECTION_OPTION_DOESNT_EXISTS 5181
|
||||
#define ER_X_INVALID_VALIDATION_SCHEMA 5182
|
||||
#define ER_X_CAPABILITY_NOT_FOUND 5002
|
||||
#define ER_X_INVALID_PROTOCOL_DATA 5003
|
||||
|
||||
#define ER_X_SERVICE_ERROR 5010
|
||||
#define ER_X_SESSION 5011
|
||||
#define ER_X_INVALID_ARGUMENT 5012
|
||||
#define ER_X_MISSING_ARGUMENT 5013
|
||||
#define ER_X_BAD_INSERT_DATA 5014
|
||||
#define ER_X_CMD_NUM_ARGUMENTS 5015
|
||||
#define ER_X_CMD_ARGUMENT_TYPE 5016
|
||||
#define ER_X_CMD_ARGUMENT_VALUE 5017
|
||||
#define ER_X_BAD_UPDATE_DATA 5050
|
||||
#define ER_X_BAD_TYPE_OF_UPDATE 5051
|
||||
#define ER_X_BAD_COLUMN_TO_UPDATE 5052
|
||||
#define ER_X_BAD_MEMBER_TO_UPDATE 5053
|
||||
#define ER_X_BAD_STATEMENT_ID 5110
|
||||
#define ER_X_BAD_CURSOR_ID 5111
|
||||
#define ER_X_BAD_SCHEMA 5112
|
||||
#define ER_X_BAD_TABLE 5113
|
||||
#define ER_X_BAD_PROJECTION 5114
|
||||
#define ER_X_DOC_ID_MISSING 5115
|
||||
#define ER_X_DOC_ID_DUPLICATE 5116
|
||||
#define ER_X_DOC_REQUIRED_FIELD_MISSING 5117
|
||||
#define ER_X_PROJ_BAD_KEY_NAME 5120
|
||||
#define ER_X_BAD_DOC_PATH 5121
|
||||
#define ER_X_CURSOR_EXISTS 5122
|
||||
#define ER_X_EXPR_BAD_OPERATOR 5150
|
||||
#define ER_X_EXPR_BAD_NUM_ARGS 5151
|
||||
#define ER_X_EXPR_MISSING_ARG 5152
|
||||
#define ER_X_EXPR_BAD_TYPE_VALUE 5153
|
||||
#define ER_X_EXPR_BAD_VALUE 5154
|
||||
#define ER_X_INVALID_COLLECTION 5156
|
||||
#define ER_X_INVALID_ADMIN_COMMAND 5157
|
||||
#define ER_X_EXPECT_NOT_OPEN 5158
|
||||
#define ER_X_EXPECT_FAILED 5159
|
||||
#define ER_X_EXPECT_BAD_CONDITION 5160
|
||||
#define ER_X_EXPECT_BAD_CONDITION_VALUE 5161
|
||||
#define ER_X_INVALID_NAMESPACE 5162
|
||||
#define ER_X_BAD_NOTICE 5163
|
||||
#define ER_X_CANNOT_DISABLE_NOTICE 5164
|
||||
#define ER_X_BAD_CONFIGURATION 5165
|
||||
#define ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS 5167
|
||||
|
||||
#endif // _MYSQLX_ERROR_H_
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
* documentation. The authors of MySQL hereby grant you an additional
|
||||
* permission to link the program and your derivative works with the
|
||||
* separately licensed software that they have included with MySQL.
|
||||
*
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
|
@ -19,7 +19,8 @@
|
|||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
||||
* 02110-1301 USA
|
||||
*/
|
||||
|
||||
/* Version numbers for X Plugin */
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue