28章扩展MySQL

每一个插件库，包含服务器插件必须包括一个图书馆描述符包含文件中的每个服务器插件一般插件描述符。本节讨论如何为服务器插件写的图书和一般描述。

图书馆的描述符必须定义两个符号：

如果服务器不在图书馆找到这两个符号，它不接受它作为一个合法的插件库，拒绝一个错误。这可以防止使用一个插件的目的，除非它是专门图书馆作为一个插件库的建立。

定义两个符号的传统方法是通过使用mysql_declare_plugin()和MySQL _宣布_ _端插件宏从plugin.h文件：

MySQL _宣布（_插件name）... one or more server plugin descriptors here ...MySQL _声明_插件_结局；

每个服务器插件必须有一个大致的描述，提供信息的服务器插件API。一般描述为所有插件类型相同的结构。这个st_mysql_plugin结构中的H的插件文件定义描述符：

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)(void *);  /* the function to invoke when plugin is loaded */
  int (*deinit)(void *);/* 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 */
};

这个st_mysql_plugin描述符结构构件应用如下。char *成员国应指定为零终止字符串。

服务器调用init和deinit函数在一般插件描述符时，加载和卸载插件。他们没有任何使用的插件，如当一个SQL语句导致插件被调用。

例如，广义信息库包含一个全文解析插件命名simple_parser看起来像这样：

mysql_declare_plugin（ftexample）{ mysql_ftparser_plugin，/ *型* / / * * / simple_parser_descriptor，描述“simple_parser”/名字/甲骨文公司/ * * /”，作者简单的文本解析器”，/ *说明* / plugin_license_gpl，/ *插件许可*/ /*初始化函数simple_parser_plugin_init，（当加载）* / / * simple_parser_plugin_deinit，deinit功能（空载时）* / / * * /版本端口，simple_status，/ * * / simple_system_variables状态变量，系统变量/ * * /空，0 } mysql_declare_plugin_end；

为全文解析插件的类型必须MYSQL_FTPARSER_PLUGIN。这是识别插件作为法律中使用的价值与解析当创建一个条款FULLTEXT指数（没有其他的插件式是合法的这一条款。）

plugin.h定义MySQL _宣布_（插件）和mysql_declare_plugin_end这样的宏：

#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}}

当宏作为上面，他们扩大到下面的代码，它定义了所需的符号（_mysql_plugin_interface_version_和_ MySQL以_ _ _插件）：

int _mysql_plugin_interface_version_= MYSQL_PLUGIN_INTERFACE_VERSION;
int _mysql_sizeof_struct_st_plugin_= sizeof(struct st_mysql_plugin);
struct st_mysql_plugin _mysql_plugin_declarations_[]= {
{
  MYSQL_FTPARSER_PLUGIN,      /* type                            */
  &simple_parser_descriptor,  /* descriptor                      */
  "simple_parser",            /* name                            */
  "Oracle Corporation",       /* author                          */
  "Simple Full-Text Parser",  /* description                     */
  PLUGIN_LICENSE_GPL,         /* plugin license                  */
  simple_parser_plugin_init,  /* init function (when loaded)     */
  simple_parser_plugin_deinit,/* deinit function (when unloaded) */
  0x0001,                     /* version                         */
  simple_status,              /* status variables                */
  simple_system_variables,    /* system variables                */
  NULL,
  0
}
  ,{0,0,0,0,0,0,0,0,0,0,0,0}}
};

前面的示例声明的一般描述一个插件，但可以声明多个插件。列表的声明一个接一个的mysql_declare_plugin()和MySQL _宣布_ _端插件通过commas，分隔。

MySQL服务器插件可以使用C或C（或另一种语言，可以使用C调用约定）。如果你写一个C的插件，一个C的功能，你不应该使用恒定的变量初始化的全局结构。等建筑构件st_mysql_plugin结构应该只有常数变量初始化。这个简单的描述符出现早在C插件允许因为它满足要求：

mysql_declare_plugin(ftexample)
{
  MYSQL_FTPARSER_PLUGIN,      /* type                            */
  &simple_parser_descriptor,  /* descriptor                      */
  "simple_parser",            /* name                            */
  "Oracle Corporation",       /* author                          */
  "Simple Full-Text Parser",  /* description                     */
  PLUGIN_LICENSE_GPL,         /* plugin license                  */
  simple_parser_plugin_init,  /* init function (when loaded)     */
  simple_parser_plugin_deinit,/* deinit function (when unloaded) */
  0x0001,                     /* version                         */
  simple_status,              /* status variables                */
  simple_system_variables,    /* system variables                */
  NULL,
  0
}
mysql_declare_plugin_end;

这里是另一个写的一般描述的有效方法。它采用恒定的变量显示插件名称、作者、和描述：

const char *simple_parser_name = "simple_parser";
const char *simple_parser_author = "Oracle Corporation";
const char *simple_parser_description = "Simple Full-Text Parser";

mysql_declare_plugin(ftexample)
{
  MYSQL_FTPARSER_PLUGIN,      /* type                            */
  &simple_parser_descriptor,  /* descriptor                      */
  simple_parser_name,         /* name                            */
  simple_parser_author,       /* author                          */
  simple_parser_description,  /* description                     */
  PLUGIN_LICENSE_GPL,         /* plugin license                  */
  simple_parser_plugin_init,  /* init function (when loaded)     */
  simple_parser_plugin_deinit,/* deinit function (when unloaded) */
  0x0001,                     /* version                         */
  simple_status,              /* status variables                */
  simple_system_variables,    /* system variables                */
  NULL,
  0
}
mysql_declare_plugin_end;

然而，以下通用描述符无效。它采用结构成员显示插件名称、作者、和描述，但结构不考虑常数初始化：

typedef struct
{
  const char *name;
  const char *author;
  const char *description;
} plugin_info;

plugin_info parser_info = {
  "simple_parser",
  "Oracle Corporation",
  "Simple Full-Text Parser"
};

mysql_declare_plugin(ftexample)
{
  MYSQL_FTPARSER_PLUGIN,      /* type                            */
  &simple_parser_descriptor,  /* descriptor                      */
  parser_info.name,           /* name                            */
  parser_info.author,         /* author                          */
  parser_info.description,    /* description                     */
  PLUGIN_LICENSE_GPL,         /* plugin license                  */
  simple_parser_plugin_init,  /* init function (when loaded)     */
  simple_parser_plugin_deinit,/* deinit function (when unloaded) */
  0x0001,                     /* version                         */
  simple_status,              /* status variables                */
  simple_system_variables,    /* system variables                */
  NULL,
  0
}
mysql_declare_plugin_end;

服务器插件接口使插件暴露状态变量和系统变量的使用status_vars和系统的_普通的钢笔将军

这个status_varsmember of the General插件描述符，if not to an array of 0点圣_ _ _是MySQL的表演结构，其中每一个状态变量的描述，其次是一个设置为所有成员结构。这个st_mysql_show_var结构定义：

struct圣_ MySQL _是教育节目_ { char * name；char *枚举枚举值；_ MySQL _秀_型；}；

下表显示了允许的状态变量type值和对应的变量应该是什么。

对于SHOW_FUNC类型、函数调用和填补它外面的参数，从而提供了可变信息显示。这个签名功能：

#define SHOW_VAR_FUNC_BUFF_SIZE 1024

typedef int (*mysql_show_var_func) (void *thd,
                                    struct st_mysql_show_var *out,
                                    char *buf);

这个system_vars的成员，如果不是0，指向一个数组圣_ MySQL是_ _缝合的结构，分别描述了系统变量（也可以从命令行或配置文件），其次是设置为0的所有成员结构。这个st_mysql_sys_var结构定义如下：

STRT St MySQL MySQL MySQL Sys Sys Le Var { int Flags；Const Char * Name，* E（* check）（thd *，斯特拉斯（* * check）（thd *，斯特拉斯（* * check）（thd *，斯特拉斯（* * Check）（Var Var Var Var * Var Var * Var Var * Var）；void（* update）（thd *，斯特拉斯- MysQL Mysql Sys Var Var（Var），void *，Const Vod *）；}；}

额外的字段添加的要求取决于标志。

为方便起见，有一些宏定义，使在一个插件更简单的创建新的系统变量。

在宏，下面的字段是可用的：

系统变量可以用静态变量直接或通过使用SYSVAR()访问宏。这个sysvar（的）宏提供的完整性。通常只能用在代码不能直接访问底层变量。

例如：

static int my_foo;
static MYSQL_SYSVAR_INT(foo_var, my_foo,
                        PLUGIN_VAR_RQCMDARG, "foo comment",
                        NULL, NULL, 0, 0, INT_MAX, 0);
 ...
   SYSVAR(foo_var)= value;
   value= SYSVAR(foo_var);
   my_foo= value;
   value= my_foo;

会话变量只能通过访问THDVAR()存取宏。例如：

static MYSQL_THDVAR_BOOL(some_flag,                         PLUGIN_VAR_NOCMDARG, "flag comment",                         NULL, NULL, FALSE); ...   if (THDVAR(thd, some_flag))   {     do_something();     THDVAR(thd, some_flag)= FALSE;   }

全球所有的会话系统变量必须公布mysqld使用前。这是通过构造一个做NULL终止的变量数组，链接到它的插件接口。例如:

static struct st_mysql_sys_var *my_plugin_vars[]= {  MYSQL_SYSVAR(foo_var),  MYSQL_SYSVAR(some_flag),  NULL};mysql_declare_plugin(fooplug){  MYSQL_..._PLUGIN,  &plugin_data,  "fooplug",  "foo author",  "This does foo!",  PLUGIN_LICENSE_GPL,  foo_init,  foo_fini,  0x0001,  NULL,  my_plugin_vars,  NULL,  0}mysql_declare_plugin_end;

以下便利宏使你申报不同类型的系统变量：

在内部，所有的可变和插件系统变量都存储在一个HASH结构

服务器的命令行帮助文本显示是由编译DYNAMIC_ARRAY所有变量的命令行选项，相关排序，然后遍历每个选项来显示。

当一个命令行选项已被处理，然后离开argv由_选项（处理）功能（my_getopt.c）；实际上，它是消耗。

服务器进程的命令行选项的插件的安装过程后立即插件已成功加载在插件初始化函数被称为

在运行时加载的插件不从任何配置选项的利益必须有可用的默认设置。一旦安装，它们装在mysqld初始化和配置选项可以设置在命令行或在my.cnf

插件应该考虑thd参数是只读的

每个客户端插件必须有一个描述符提供信息给客户端插件API。描述符结构由一组固定的成员共同所有的客户端插件，其次是任何成员特定的插件式。

这个st_mysql_client_plugin结构中的_ plugin.h客户端文件定义了一个“通用“描述符包含普通成员：

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)();
  int (*options)(const char *option, const void *);
};

常见的st_mysql_client_plugin描述符结构构件应用如下。char *成员国应指定为零终止字符串。

对于一个给定的客户端插件类型，常见的描述符成员可能跟其他成员必须实施这种类型的插件。例如，在st_mysql_client_plugin_AUTHENTICATION身份验证插件结构函数结束时，客户端库的调用进行身份验证。

声明一个插件，使用mysql_declare_client_plugin()和_端插件_ _ MySQL客户端宏：

mysql_declare_client_plugin(plugin_type)
   ... members common to all client plugins ...
   ... type-specific extra members ...
mysql_end_client_plugin;

不指定type或interface_version成员明确。这个mysql_declare_client_plugin()宏使用的plugin_type参数值自动生成。例如，宣布这样一个认证客户端插件：

mysql_declare_client_plugin（认证）”my_auth_plugin”、“作者姓名”，“我的客户端身份验证插件”，{1,0,0}，“GPL”，空，my_auth_init，my_auth_deinit，my_auth_options，my_auth_mainmysql_end_client_plugin；

这一声明使用AUTHENTICATION参数设置类型和interface_version成员MySQL客户端认证_ _ _插件和MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION

根据插件类型，描述可能有其他成员的普通成员。例如，一个身份验证插件，有一个功能（my_auth_main()在描述符只显示与服务器通信，处理）。看到第28.2.4.9，“写作认证插件”

通常，一个支持身份验证插件的使用会导致一个插件是通过调用客户端程序mysql_options()设置_ _ auth mysql默认和MYSQL_PLUGIN_DIR备选办法：

char *plugin_dir = "path_to_plugin_dir";char *default_auth = "plugin_name“；／＊…过程命令行选项。* / MySQL（MySQL和MySQL _选项，你_ _插件插件，你_）；_ options（MySQL和MySQL，MySQL _ _ AUTH的违约，违约_ auth）；

通常情况下，该计划还将接受--plugin-dir和-默认的认证这使用户能够覆盖默认值选项。

如果客户程序需要低级别的插件管理，客户端库中包含的函数，以st_mysql_client_plugin争论。看到第27.7.13，“C API客户端插件功能”

与一般的描述符格式是用于所有服务器插件类型声明服务器端插件（参见第28.2.4.2.1”图书馆和服务器插件，插件参数”）。for theauth_simple插件描述符看起来像这样：

mysql_declare_plugin(auth_simple){  MYSQL_AUTHENTICATION_PLUGIN,  &auth_simple_handler,                 /* type-specific descriptor */  "auth_simple",                        /* plugin name */  "Author Name",                        /* author */  "Any-password authentication plugin", /* description */  PLUGIN_LICENSE_GPL,                   /* license type */  NULL,                                 /* no init function */  NULL,                                 /* no deinit function */  0x0100,                               /* version = 1.0 */  NULL,                                 /* no status variables */  NULL,                                 /* no system variables */  NULL,                                 /* no reserved information */  0                                     /* no flags */}mysql_declare_plugin_end;

这个name成员（_简单认证）指示要使用的名称在报表如插件引用INSTALL PLUGIN或UNINSTALL PLUGIN。这也显示的名字SHOW PLUGINS或INFORMATION_SCHEMA.PLUGINS

这个auth_simple_handler一般的描述符指向特定类型说明符成员。为验证插件，特定类型的描述符的实例圣_ _ auth mysql结构（定义在plugin_auth.h）：

结构st_mysql_auth { int interface_version；const char* client_auth_plugin；int（* authenticate_user）（mysql_plugin_vio * VIO，mysql_server_auth_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缓冲区长度）；int（* set_salt）（const char *密码，password_len unsigned int，unsigned char *盐，unsigned char * salt_len）；const unsigned long authentication_flags；}；

这个st_mysql_auth这些成员的结构：

这个client_auth_plugin成员如果一个特定的插件是必需的指示客户端插件的名称。一个值无效的方法“任何插件“在后一种情况下，任何插件客户端使用会。如果服务器插件不关心客户端插件或用户名称或密码发送这是有用的。例如，这可能如果服务器插件认证只有本地客户和使用操作系统的一些特性而不是由客户端插件发送的信息是真实的。

为auth_simple特定类型的描述符，看起来像这样：

static struct st_mysql_auth auth_simple_handler ={  MYSQL_AUTHENTICATION_INTERFACE_VERSION,  "auth_simple",             /* required client-side plugin name */  auth_simple_server         /* server-side plugin main function */  generate_auth_string_hash, /* generate digest from password string */  validate_auth_string_hash, /* validate password digest */  set_salt,                  /* generate password salt value */  AUTH_FLAG_PRIVILEGED_USER_FOR_PASSWORD_CHANGE};

主要功能，auth_simple_server()，有两个参数代表一个I/O结构和MySQL服务器_ _ auth _ info结构。结构定义，发现plugin_auth.h，看起来像这样：

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[MYSQL_USERNAME_LENGTH+1];
  char external_user[512];
  int  password_used;
  const char *host_or_ip;
  unsigned int host_or_ip_length;
} MYSQL_SERVER_AUTH_INFO;

设置字符串的字符的gb3212的成员。如果有一个_length件与字符串相关，提示字符串的字节长度。字符串也可以终止。

当一个身份验证插件是由服务器调用，它应该解释MYSQL_SERVER_AUTH_INFO结构成员如下。其中一些是用来设置在客户端会话的SQL函数或系统变量的值，如。

这个auth_simple主要功能，认证服务器_ _（简单），读取密码（一个null结尾的字符串）从客户和成功如果密码是空的（第一个字节不为空）：

static int auth_simple_server (MYSQL_PLUGIN_VIO *vio,
                               MYSQL_SERVER_AUTH_INFO *info)
{
  unsigned char *pkt;
  int pkt_len;

  /* read the password as null-terminated string, fail on error */
  if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
    return CR_ERROR;

  /* fail on empty password */
  if (!pkt_len || *pkt == '\0')
  {
    info->password_used= PASSWORD_USED_NO;
    return CR_ERROR;
  }

  /* accept any nonempty password */
  info->password_used= PASSWORD_USED_YES;

  return CR_OK;
}

主函数应该返回一个如下表所示的错误代码。

关于握手的工作的一个例子，看plugin/auth/dialog.c源文件

服务器在性能模式插件错误计数host_cache表

auth_simple_server()基本是这样的，它不只是设置会员是否收到密码使用认证信息结构。

一个支持代理用户插件必须返回到服务器的代理的用户的名称（MySQL的用户权限的用户应该得到）。为此，插件必须设置info->authenticated_as会员代理的用户的名称。关于代理，看第6.3.11”代理用户”，和第28.2.4.9.4，实施代理支持用户认证插件”

这个generate_authentication_string这个插件描述符成员需要密码和生成的密码哈希（摘要）从它：

对于auth_simple插件的generate_auth_string_hash()功能的实现generate_authentication_string会员它只是让一份密码，除非它太长，适合在输出缓冲区。

int generate_auth_string_hash(char *outbuf, unsigned int *buflen,                              const char *inbuf, unsigned int inbuflen){  /*    fail if buffer specified by server cannot be copied to output buffer  */  if (*buflen < inbuflen)    return 1;   /* error */  strncpy(outbuf, inbuf, inbuflen);  *buflen= strlen(inbuf);  return 0;     /* success */}

这个validate_authentication_stringMember of the lugier叙述performance to Password HAH：

对于auth_simple插件的验证性_ _ _字符串的hash（）功能的实现validate_authentication_string会员它返回成功的条件：

validate_auth_string_hash（int，char *const inbuf __attribute__（（未使用）），unsigned int缓冲区长度__attribute__（（未使用）））{ return 0；/* */ }成功

这个set_salt这个插件描述符成员只能被使用mysql_native_password（这个插件部分6.5.1.1，“本土认证”）。其他认证的插件，你可以使用这个简单的实现：

int set_salt(const char* password __attribute__((unused)),
             unsigned int password_len __attribute__((unused)),
             unsigned char* salt __attribute__((unused)),
             unsigned char* salt_len)
{
  *salt_len= 0;
  return 0;     /* success */
}

这个authentication_flags这个插件描述符成员包含影响插件运行的旗帜。允许的标志：

与申报客户端插件描述符mysql_declare_client_plugin()和_端插件_ _ MySQL客户端宏（See第28.2.4.2.3，“客户端插件描述符”）。for theauth_simple插件描述符看起来像这样：

mysql_declare_client_plugin(AUTHENTICATION)  "auth_simple",                        /* plugin name */  "Author Name",                        /* author */  "Any-password authentication plugin", /* description */  {1,0,0},                              /* version = 1.0.0 */  "GPL",                                /* license type */  NULL,                                 /* for internal use */  NULL,                                 /* no init function */  NULL,                                 /* no deinit function */  NULL,                                 /* no option-handling function */  auth_simple_client                    /* main function */mysql_end_client_plugin;

描述符成员从插件的名称通过选项处理功能是所有客户端插件类型常见。（描述，看第28.2.4.2.3，“客户端插件描述符”以下的普通成员。），有一个特定的描述符验证插件新增成员。这是“主要“功能，与服务器处理通信。该函数有两个参数代表一个I/O结构和连接处理。我们简单的任何密码的插件，主要功能只是写到服务器用户提供的密码：

static int auth_simple_client (MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
  int res;

  /* send password as null-terminated string in clear text */
  res= vio->write_packet(vio, (const unsigned char *) mysql->passwd,
                         strlen(mysql->passwd) + 1);

  return res ? CR_ERROR : CR_OK;
}

主函数应该返回一个如下表所示的错误代码。

CR_OK_HANDSHAKE_COMPLETE表明客户已经完成了它的部分成功，读了最后一包。一个客户端插件可能会返回cr_ok_handshake_complete如果在认证协议的往返次数，事先是不知道的，插件必须读另一包来确定是否认证完成。

编译和安装一个插件库文件，使用说明第28.2.4.3，编译和安装插件库”。使库文件可供使用，它安装在插件目录（目录命名的plugin_dir系统变量

与服务器登记服务器端插件。例如，在服务器启动时加载的插件，使用--plugin-load=auth_simple.so选项（调整。所以足够的你的平台

创建一个用户来说，服务器将使用auth_simple插件的认证：

MySQL的>CREATE USER 'x'@'localhost'->IDENTIFIED WITH auth_simple;

使用客户端程序连接到服务器的用户x。服务器端_简单认证插件与客户端程序，它应该使用客户端auth_simple插件，后者发送密码到服务器。服务器插件应该拒绝连接，发送一个空的密码和接受连接，发送一个空的密码。调用客户端程序去验证这：

内核mysql --user=x --skip-password错误45（28000）：用户访问被拒绝“X '@'本地主机'（使用密码：无）内核>mysql --user=x --password输入密码：abcMySQL的>

因为服务器插件接受任何非空密码，它应该被认为是不安全的。经过测试的插件来验证它，重新启动服务器没有--plugin-load选择不indavertently离开服务器运行不安全的身份验证插件加载。同时，降低用户DROP USER 'x'@'localhost'

关于加载和使用身份验证插件的更多信息，参见第5.6.1，“安装和卸载插件”，和第6.3.10，“认证”

如果你正在写一个支持身份验证插件使用的客户端程序，通常这样的程序使插件可以通过调用mysql_options()设置_ _ auth mysql默认和MYSQL_PLUGIN_DIR备选办法：

char *plugin_dir = "path_to_plugin_dir";char *default_auth = "plugin_name“；／＊…过程命令行选项。* / MySQL（MySQL和MySQL _选项，你_ _插件插件，你_）；_ options（MySQL和MySQL，MySQL _ _ AUTH的违约，违约_ auth）；

通常情况下，该计划还将接受--plugin-dir和-默认的认证这使用户能够覆盖默认值选项。

如果客户程序需要低级别的插件管理，客户端库中包含的函数，以st_mysql_client_plugin争论。看到第27.7.13，“C API客户端插件功能”

一个可插拔认证使得能力是代理用户（见第6.3.11”代理用户”）。一个服务器端的身份验证插件参与代理的用户的支持，这些条件必须满足：

换句话说，代理用户支持的插件所需的唯一的方面是，它集authenticated_as对代理的用户名。其余的是可选的（设置external_user）或通过使用SQL语句的DBA。

如何验证插件并确定代理用户返回时，代理用户连接？这取决于插件。通常情况下，插件地图客户端代理用户通过服务器传递给它的字符串验证。这串来自AS部分的确定的条款CREATE USER语句指定认证的插件的使用。

插件开发者决定认证字符串的语法规则，根据这些规则实现了插件。假设一个插件以逗号分隔的对地图的外部使用者的MySQL用户列表。例如:

CREATE USER ''@'%.example.com'
  IDENTIFIED WITH my_plugin AS 'extuser1=mysqlusera, extuser2=mysqluserb'
CREATE USER ''@'%.example.org'
  IDENTIFIED WITH my_plugin AS 'extuser1=mysqluserc, extuser2=mysqluserd'

当服务器调用插件来验证客户端，它通过适当的认证字符串插件。插件负责：

例如，如果extuser2连接从一个example.com主机，服务器通过'extuser1=mysqlusera, extuser2=mysqluserb'的插件，而插件应该复制mysqluserb进入之内authenticated_as与终止空字节。如果extuser2连接从一个example.org主机，服务器通过'extuser1=mysqluserc, extuser2=mysqluserd'，和插件应该复制mysqluserd相反

如果在映射不匹配，行动取决于插件。如果比赛是必需的，该插件可能会返回一个错误。或插件可能只是简单地返回客户的名字；在这种情况下，它不会改变authenticated_as，和服务器将不会把客户作为代理。

下面的示例演示如何处理代理用户使用一个插件命名auth_simple_proxy。像_简单认证插件之前描述的，auth_simple_proxy接受任何非空密码是有效的（因此不应在生产环境中使用的）。此外，它检查auth _字符串验证字符串的成员和使用这些非常简单的规则来解释它：

用于测试，建立一个帐户，不代理根据前面的规则，一个是。这意味着，一个帐户没有AS条款，和一个包括：作为条款名称代理用户：

CREATE USER 'plugin_user1'@'localhost'
  IDENTIFIED WITH auth_simple_proxy;
CREATE USER 'plugin_user2'@'localhost'
  IDENTIFIED WITH auth_simple_proxy AS 'proxied_user';

此外，创建代理用户帐户授予plugin_user2这个PROXY特权的信息：

创建用户的proxied_user '@'本地主机'确定' proxied_user_pass”；授予代理的proxied_user '@'本地主机' ' plugin_user2 '@'本地主机'；

在服务器调用验证插件，它集authenticated_as到客户端的用户名。如果用户是一个代理，插件的设置authenticated_as对代理的用户名。为auth_simple_proxy，这意味着它必须检查auth _字符串值，如果值为空，将它复制到authenticated_as成员还作为代理的用户的名称。此外，当代理时，插件的设置external_user会员客户的用户名；这就值了external_user系统变量

static int auth_simple_proxy_server (MYSQL_PLUGIN_VIO *vio,                                     MYSQL_SERVER_AUTH_INFO *info){  unsigned char *pkt;  int pkt_len;  /* read the password as null-terminated string, fail on error */  if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)    return CR_ERROR;  /* fail on empty password */  if (!pkt_len || *pkt == '\0')  {    info->password_used= PASSWORD_USED_NO;    return CR_ERROR;  }  /* accept any nonempty password */  info->password_used= PASSWORD_USED_YES;  /* if authentication string is nonempty, use as proxied user name */  /* and use client name as external_user value */  if (info->auth_string_length > 0)  {    strcpy (info->authenticated_as, info->auth_string);    strcpy (info->external_user, info->user_name);  }  return CR_OK;}

连接成功后，该USER()函数应该显示连接用户和主机名，和CURRENT_USER()应说明其权限申请会议期间账户。后者的价值要连接的用户帐户如果没有代理或代理的代理帐户时如果发生。

编译和安装插件，然后测试它。首先，连接plugin_user1：

内核mysql --user=plugin_user1 --password输入密码：x

在这种情况下，不应该有任何代理：

mysql> SELECT USER(), CURRENT_USER(), @@proxy_user, @@external_user\G
*************************** 1. row ***************************
         USER(): plugin_user1@localhost
 CURRENT_USER(): plugin_user1@localhost
   @@proxy_user: NULL
@@external_user: NULL

然后连接plugin_user2：

内核mysql --user=plugin_user2 --password输入密码：x

在这种情况下，plugin_user2应向代理proxied_user：

mysql> SELECT USER(), CURRENT_USER(), @@proxy_user, @@external_user\G
*************************** 1. row ***************************
         USER(): plugin_user2@localhost
 CURRENT_USER(): proxied_user@localhost
   @@proxy_user: 'plugin_user2'@'localhost'
@@external_user: 'plugin_user2'@'localhost'

MySQL包括测试协议跟踪插件，足以说明可以从插件的信息，作为一个写作指导其他协议跟踪插件。看看测试插件，使用MySQL源分布；二元分布的测试插件禁用了。

使测试协议跟踪插件的配置MySQLWITH_TEST_TRACE_PLUGINCMake启用选项。这使得测试跟踪插件来建立和MySQL客户端程序来加载它，但没有影响默认插件。使用这些环境变量插件控制：

给定一个MySQL的安装与测试插件源建成启用，你可以看到一丝之间的通信MySQL客户端和MySQL服务器如下：

shell> export MYSQL_TEST_TRACE_DEBUG=1
shqll> mysql
test_trace: Test trace plugin initialized
test_trace: Starting tracing in stage CONNECTING
test_trace: stage: CONNECTING, event: CONNECTING
test_trace: stage: CONNECTING, event: CONNECTED
test_trace: stage: WAIT_FOR_INIT_PACKET, event: READ_PACKET
test_trace: stage: WAIT_FOR_INIT_PACKET, event: PACKET_RECEIVED
test_trace: packet received: 87 bytes
  0A 35 2E 37 2E 33 2D 6D  31 33 2D 64 65 62 75 67   .5.7.3-m13-debug
  2D 6C 6F 67 00 04 00 00  00 2B 7C 4F 55 3F 79 67   -log.....+|OU?yg
test_trace: 004: stage: WAIT_FOR_INIT_PACKET, event: INIT_PACKET_RECEIVED
test_trace: 004: stage: AUTHENTICATE, event: AUTH_PLUGIN
test_trace: 004: Using authentication plugin: mysql_native_password
test_trace: 004: stage: AUTHENTICATE, event: SEND_AUTH_RESPONSE
test_trace: 004: sending packet: 188 bytes
  85 A6 7F 00 00 00 00 01  21 00 00 00 00 00 00 00   .?......!.......
  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00   ................
...
mysql> quit
test_trace: 008: stage: READY_FOR_COMMAND, event: SEND_COMMAND
test_trace: 008: QUIT
test_trace: 008: stage: READY_FOR_COMMAND, event: PACKET_SENT
test_trace: 008: packet sent: 0 bytes
test_trace: 008: stage: READY_FOR_COMMAND, event: DISCONNECTED
test_trace: 008: Connection  closed
test_trace: 008: Tracing connection has ended
Bye
test_trace: Test trace plugin de-initialized

禁用跟踪输出，这样做：

shell> MYSQL_TEST_TRACE_DEBUG=

本节讨论如何编写一个基本协议跟踪插件命名simple_trace。这个插件提供了一个框架，显示如何设置客户端插件描述符和创建跟踪相关的回调函数。进入simple_trace这些功能是基本的，做点其他说明的参数要求。看到了一丝插件可以使用跟踪事件的信息，检查测试协议跟踪插件的源文件（test_trace_plugin.cc在libmysql一个MySQL源分布目录）。但是，请注意，st_mysql_client_plugin_TRACE结构使用不同于用通常的客户端插件声明宏结构。特别是，第一个成员是明确定义的，不隐式声明的宏。

几个头文件包含协议跟踪插件相关的信息：

写一个协议跟踪插件，包括头文件的插件的源文件。其他MySQL或一般的头文件，也可能是需要的，这取决于插件的功能和要求。

#include <mysql/plugin_trace.h>
#include <mysql.h>

plugin_trace.h包括_ plugin.h客户端，所以你不需要包含后者的文件明确。

与申报客户端插件描述符mysql_declare_client_plugin()和_端插件_ _ MySQL客户端宏（See第28.2.4.2.3，“客户端插件描述符”）。for thesimple_trace插件描述符看起来像这样：

mysql_declare_client_plugin(TRACE)  "simple_trace",                 /* plugin name */  "Author Name",                  /* author */  "Simple protocol trace plugin", /* description */  {1,0,0},                        /* version = 1.0.0 */  "GPL",                          /* license type */  NULL,                           /* for internal use */  plugin_init,                    /* initialization function */  plugin_deinit,                  /* deinitialization function */  plugin_options,                 /* option-handling function */  trace_start,                    /* start-trace function */  trace_stop,                     /* stop-trace function */  trace_event                     /* event-handling function */mysql_end_client_plugin;

描述符成员从插件的名称通过选项处理功能是所有客户端插件类型常见。以下的普通成员实施跟踪事件处理的成员。

函数成员的插件不需要处理可以声明为NULL在描述，在这种情况下，你不需要写任何相应的功能。为了显示参数语法，下面的讨论中实施描述符列出所有功能，即使有些人没有，

初始化，deinitialization选项功能，和所有客户端插件共同声明如下。一个描述参数和返回值，看第28.2.4.2.3，“客户端插件描述符”

static int
plugin_init(char *errbuf, size_t errbuf_len, int argc, va_list args)
{
  return 0;
}

static int
plugin_deinit()
{
  return 0;
}

static int
plugin_options(const char *option, const void *value)
{
  return 0;
}

该客户端插件描述符的跟踪特定的成员函数。下面的描述提供更详细的关于他们是如何使用的。每一个的第一个参数是一个指向插件实例的情况下你需要访问的实现。

trace_start()：这个功能是在每个跟踪连接开始叫（每个连接，启动后载入插件）。它是通过连接处理和协议阶段，跟踪开始。trace_start()分配需要的内存trace_event()功能，如果有，并返回一个指向它的指针。如果没有记忆是必要的，这个函数返回无效的

static void*
trace_start(struct st_mysql_client_plugin_TRACE *self,
            MYSQL *conn,
            enum protocol_stage stage)
{
  struct st_trace_data *plugin_data= malloc(sizeof(struct st_trace_data));

  fprintf(stderr, "Initializing trace: stage %d\n", stage);
  if (plugin_data)
  {
    memset(plugin_data, 0, sizeof(struct st_trace_data));
    fprintf(stderr, "Trace initialized\n");
    return plugin_data;
  }
  fprintf(stderr, "Could not initialize trace\n");
  exit(1);
}

trace_stop()：这个函数被调用时跟踪连接。这通常发生在连接关闭，但可以发生。例如,trace_event()可以在任何时候返回非零值，使连接跟踪终止。trace_stop()然后被即使连接还没有结束。

trace_stop()通过连接句柄和指针分配的内存trace_start()（NULL如果没有）。如果你不知道无效的，trace_stop()要释放内存。这个函数没有返回值。

静态voidtrace_stop（struct st_mysql_client_plugin_trace *自我，mysql * Conn，void * plugin_data）{ fprintf（stderr，“终止微量\n”）；如果（plugin_data）自由（plugin_data）；}

trace_event()：这个功能是为每一个事件的发生。它是通过指针分配的内存trace_start()（NULL如果没有），连接句柄，当前协议阶段和事件代码，数据和事件数据。这个函数返回0，继续跟踪，如果跟踪非零应停止。

static inttrace_event(struct st_mysql_client_plugin_TRACE *self,            void *plugin_data,            MYSQL *conn,            enum protocol_stage stage,            enum trace_event event,            struct st_trace_event_args args){  fprintf(stderr, "Trace event received: stage %d, event %d\n", stage, event);  if (event == TRACE_EVENT_DISCONNECTED)    fprintf(stderr, "Connection closed\n");  return 0;}

跟踪框架关闭连接跟踪连接结束时，所以trace_event()应该返回非零如果你想终止跟踪连接的早期。假设你想跟踪某只连接MySQL账户。认证通过后，你可以检查用户连接名称和停止跟踪如果不是用户在其中你有兴趣。

每次调用trace_event()，的st_trace_event_args结构包含事件数据。它有这个定义：

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;
};

对于不同的事件类型的st_trace_event_args结构包含以下信息描述。所有的长度，以字节为单位。未使用的成员设置为零/NULL

AUTH_PLUGIN事件：

plugin_name插件的名称

SEND_COMMAND事件：

CMD命令codehdr指向指针的headerpkt命令包headerhdr_len长度参数的命令argumentspkt_len长度

其他SEND_xxx和xxx_received事件

PKT指针或传送数据的数据长度的receivedpkt_len

PACKET_SENT事件：

pkt_len发送的字节数

编译和安装一个插件库文件，使用说明第28.2.4.3，编译和安装插件库”。使库文件可供使用，它安装在插件目录（目录命名的plugin_dir系统变量

在插件库文件编译和安装在插件目录中，你可以很容易的通过设置测试LIBMYSQL_PLUGINS环境变量插件的名称，从而影响任何使用该变量的客户端程序。MySQL就是这样的一个程序：

shell> export LIBMYSQL_PLUGINS=simple_trace
shqll> mysql
Initializing trace: stage 0
Trace initialized
Trace event received: stage 0, event 1
Trace event received: stage 0, event 2
...
Welcome to the MySQL monitor.  Commands end with ; or \g.
Trace event received
Trace event received
...
mysql> SELECT 1;
Trace event received: stage 4, event 12
Trace event received: stage 4, event 16
...
Trace event received: stage 8, event 14
Trace event received: stage 8, event 15
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)

mysql> quit
Trace event received: stage 4, event 12
Trace event received: stage 4, event 16
Trace event received: stage 4, event 3
Connection closed
Terminating trace
Bye

停止跟踪插件被加载，这样做：

shell> LIBMYSQL_PLUGINS=

也可以编写客户端程序，直接加载插件。你可以告诉客户，通过调用插件目录位于mysql_options()设置MySQL _ _插件目录选项：

char *plugin_dir = "path_to_plugin_dir";

/* ... process command-line options ... */

mysql_options(&mysql, MYSQL_PLUGIN_DIR, plugin_dir);

通常，程序也将接受--plugin-dir选项，用户可以重写默认值。

如果客户程序需要低级别的插件管理，客户端库中包含的函数，以st_mysql_client_plugin争论。看到第27.7.13，“C API客户端插件功能”

锁定服务程序的描述第28.3.1.1，“锁定服务接口”不需要是因为他们是建立在服务器安装。相同的是不是真正的用户自定义函数（UDF），映射到调用服务例程：UDFs前必须安装使用。本节介绍了如何做。关于自定义安装的一般信息，看第28.4.2.5，“UDF编译和安装”

锁定服务UDF在插件库文件位于目录下的实现plugin_dir系统变量。文件的基名称是locking_service。文件名后缀不同的平台（例如每，.soUNIX和类UNIX系统，dllWindows）

安装锁服务UDF，使用CREATE FUNCTION声明（调整。所以你的平台是必要的后缀）：

CREATE FUNCTION service_get_read_locks RETURNS INT SONAME 'locking_service.so';
CREATE FUNCTION service_get_write_locks RETURNS INT SONAME 'locking_service.so';
CREATE FUNCTION service_release_locks RETURNS INT SONAME 'locking_service.so';

如果UDF使用主复制服务器，安装在所有从服务器以及避免复制问题。

一旦安装，安装之前卸载的UDF保持。删除它们，使用DROP FUNCTION声明：

拖放功能service_get_read_locks；降功能service_get_write_locks；降功能service_release_locks；

在使用UDF锁定服务，安装根据提供的指令第28.3.1.2.1，“安装或卸载UDF锁定界面”

获取一个或多个读锁，调用这个函数：

mysql> SELECT service_get_read_locks('mynamespace', 'rlock1', 'rlock2', 10);
+---------------------------------------------------------------+
| service_get_read_locks('mynamespace', 'rlock1', 'rlock2', 10) |
+---------------------------------------------------------------+
|                                                             1 |
+---------------------------------------------------------------+

第一个参数是锁命名空间。最后一个参数是一个整数超时指示等在放弃之前获得锁多少秒。参数之间是锁的名字。

例如只显示功能获取锁锁标识符(mynamespace, rlock1)和（mynamespace，rlock2）

获得写锁而不是读锁，调用这个函数：

mysql> SELECT service_get_write_locks('mynamespace', 'wlock1', 'wlock2', 10);
+----------------------------------------------------------------+
| service_get_write_locks('mynamespace', 'wlock1', 'wlock2', 10) |
+----------------------------------------------------------------+
|                                                              1 |
+----------------------------------------------------------------+

在这种情况下，锁定标识符(mynamespace, wlock1)和（MynaesPecia，WLLL2）

释放所有的锁一个命名空间，使用此功能：

mysql> SELECT service_release_locks('mynamespace');
+--------------------------------------+
| service_release_locks('mynamespace') |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

每个锁函数返回非零成功。如果函数失败，出现错误。例如，以下错误的发生是因为锁名称不能为空：

mysql> SELECT service_get_read_locks('mynamespace', '', 10);
ERROR 3131 (42000): Incorrect locking service lock name ''.

一个会话可以获得相同的锁标识多个锁。只要一个不同的会话没有写锁的会话标识符，可以获得任意数量的读写锁。每个锁请求标识符获取一个新的锁。下面的语句获得3写锁具有相同的标识符，然后3读锁相同的标识符：

SELECT service_get_write_locks('ns', 'lock1', 'lock1', 'lock1', 0);
SELECT service_get_read_locks('ns', 'lock1', 'lock1', 'lock1', 0);

如果你检查性能架构metadata_locks在这一点上，你会发现六个不同的会话持有锁的（NNS，Lock1）标识符。（详情见第28.3.1.2.3，“锁定服务监控”。）

因为会话持有至少一个写锁上(ns, lock1)，没有其他会话可以获得锁，无论是读或写。如果会话仅持有读锁的标识符，其他会话可以获得读锁，但不能写锁。

一个叫锁锁采集获得原子，而原子不在电话。因此，对于这样一个语句如下，其中service_get_write_locks()被称为每行的结果集一次，原子是每一个人的电话，而不是作为一个整体的声明：

选择service_get_write_locks（'ns '，' lock1 '、' lock2，0）从T1的地方…；

INSERT INTO ... SELECT service_get_write_locks('ns', t1.col_name, 0) FROM t1;

锁定服务使用的是MySQL服务器元数据锁框架实现的，所以你监控锁定服务获得的锁或等待的绩效考核模式metadata_locks表

首先，使元数据锁紧装置：

mysql> UPDATE performance_schema.setup_instruments SET ENABLED = 'YES'
    -> WHERE NAME = 'wait/lock/metadata/sql/mdl';

然后获得一些锁和检查的内容metadata_locks表

MySQL的>SELECT service_get_write_locks('mynamespace', 'lock1', 0);---------------------------------------------------- | service_get_write_locks（'mynamespace '，' lock1 '，0）| ---------------------------------------------------- | 1 | ---------------------------------------------------- MySQL >SELECT service_get_read_locks('mynamespace', 'lock2', 0);我的意思是，这是一个好的服务。SELECT OBJECT_TYPE, OBJECT_SCHEMA, OBJECT_NAME, LOCK_TYPE, LOCK_STATUS->FROM performance_schema.metadata_locks->WHERE OBJECT_TYPE = 'LOCKING SERVICE'\G*************************** 1。行*************************** object_type：锁定serviceobject_schema：mynamespace object_name：lock1 lock_type：独家lock_status：授予*************************** 2。行*************************** object_type：锁定serviceobject_schema：mynamespace object_name：lock2 lock_type：共享lock_status：授予

锁有锁服务OBJECT_TYPE价值锁服务。这是不同的，例如，获取的锁GET_LOCK()功能，它有一个object_type属于USER LEVEL LOCK

锁命名空间、名称、和模式出现在OBJECT_SCHEMA，object_name，和LOCK_TYPE专栏读写锁_型锁值SHARED和独家，分别

这个LOCK_STATUS值授予为获取锁，PENDING一个锁，正在等待。你会看到悬而未决的如果一个会话持有一个写锁和另一个会议，试图获得一个具有相同标识符的锁。

SQL接口锁定服务实现本节中描述的用户定义函数。使用的例子，看第28.3.1.2.2，使用UDF锁定界面”

分享这些特色功能：

这些锁服务udf是可用的：