cleanup: sort various lists of services

include/mysql/plugin_audit.h.pp

 typedef char my_bool;
 typedef void * MYSQL_PLUGIN;
+extern struct base64_service_st {
+  int (*base64_needed_encoded_length_ptr)(int length_of_data);
+  int (*base64_encode_max_arg_length_ptr)(void);
+  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
+  int (*base64_decode_max_arg_length_ptr)();
+  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
+  int (*base64_decode_ptr)(const char *src, size_t src_len,
+                           void *dst, const char **end_ptr, int flags);
+} *base64_service;
+int base64_needed_encoded_length(int length_of_data);
+int base64_encode_max_arg_length(void);
+int base64_needed_decoded_length(int length_of_encoded_data);
+int base64_decode_max_arg_length();
+int base64_encode(const void *src, size_t src_len, char *dst);
+int base64_decode(const char *src, size_t src_len,
+                  void *dst, const char **end_ptr, int flags);
+extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
+struct encryption_service_st {
+  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
+  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
+                                          unsigned char* buffer, unsigned int* length);
+  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
+  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
+                                  const unsigned char* iv, unsigned int ivlen,
+                                  int flags, unsigned int key_id,
+                                  unsigned int key_version);
+  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
+                                    unsigned char* dst, unsigned int* dlen);
+  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
+  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
+};
+extern struct encryption_service_st encryption_handler;
+static inline unsigned int encryption_key_id_exists(unsigned int id)
+{
+  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
+}
+static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
+{
+  unsigned int unused;
+  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
+}
+static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
+                                   unsigned char* dst, unsigned int* dlen,
+                                   const unsigned char* key, unsigned int klen,
+                                   const unsigned char* iv, unsigned int ivlen,
+                                   int flags, unsigned int key_id, unsigned int key_version)
+{
+  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
+  int res1, res2;
+  unsigned int d1, d2;
+  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
+    return res1;
+  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
+  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
+  *dlen= d1 + d2;
+  return res1 ? res1 : res2;
+}
+struct st_encryption_scheme_key {
+  unsigned int version;
+  unsigned char key[16];
+};
+struct st_encryption_scheme {
+  unsigned char iv[16];
+  struct st_encryption_scheme_key key[3];
+  unsigned int keyserver_requests;
+  unsigned int key_id;
+  unsigned int type;
+  void (*locker)(struct st_encryption_scheme *self, int release);
+};
+extern struct encryption_scheme_service_st {
+  int (*encryption_scheme_encrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+  int (*encryption_scheme_decrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+} *encryption_scheme_service;
+int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+enum thd_kill_levels {
+  THD_IS_NOT_KILLED=0,
+  THD_ABORT_SOFTLY=50,
+  THD_ABORT_ASAP=100,
+};
+extern struct kill_statement_service_st {
+  enum thd_kill_levels (*thd_kill_level_func)(const void*);
+} *thd_kill_statement_service;
+enum thd_kill_levels thd_kill_level(const void*);
+typedef struct logger_handle_st LOGGER_HANDLE;
+extern struct logger_service_st {
+  void (*logger_init_mutexes)();
+  LOGGER_HANDLE* (*open)(const char *path,
+                         unsigned long long size_limit,
+                         unsigned int rotations);
+  int (*close)(LOGGER_HANDLE *log);
+  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
+  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int (*rotate)(LOGGER_HANDLE *log);
+} *logger_service;
+  void logger_init_mutexes();
+  LOGGER_HANDLE *logger_open(const char *path,
+                             unsigned long long size_limit,
+                             unsigned int rotations);
+  int logger_close(LOGGER_HANDLE *log);
+  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
+  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int logger_rotate(LOGGER_HANDLE *log);
+extern struct my_md5_service_st {
+  void (*my_md5_type)(unsigned char*, const char*, size_t);
+  void (*my_md5_multi_type)(unsigned char*, ...);
+  size_t (*my_md5_context_size_type)();
+  void (*my_md5_init_type)(void *);
+  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
+  void (*my_md5_result_type)(void *, unsigned char *);
+} *my_md5_service;
+void my_md5(unsigned char*, const char*, size_t);
+void my_md5_multi(unsigned char*, ...);
+size_t my_md5_context_size();
+void my_md5_init(void *context);
+void my_md5_input(void *context, const unsigned char *buf, size_t len);
+void my_md5_result(void *context, unsigned char *digest);
 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);
-struct st_mysql_lex_string
-{
-  char *str;
-  size_t length;
-};
-typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
-extern struct thd_alloc_service_st {
-  void *(*thd_alloc_func)(void*, unsigned int);
-  void *(*thd_calloc_func)(void*, unsigned int);
-  char *(*thd_strdup_func)(void*, const char *);
-  char *(*thd_strmake_func)(void*, const char *, unsigned int);
-  void *(*thd_memdup_func)(void*, const void*, unsigned int);
-  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
-                                        const char *, unsigned int, int);
-} *thd_alloc_service;
-void *thd_alloc(void* thd, unsigned int size);
-void *thd_calloc(void* thd, unsigned int size);
-char *thd_strdup(void* thd, const char *str);
-char *thd_strmake(void* thd, const char *str, unsigned int size);
-void *thd_memdup(void* thd, const void* str, unsigned int size);
-MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
-                                      const char *str, unsigned int size,
-                                      int allocate_lex_string);
-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_NET= 11,
-  THD_WAIT_LAST= 12
-} 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);
 extern struct progress_report_service_st {
   void (*thd_progress_init_func)(void* thd, unsigned int max_stage);
   void (*thd_progress_report_func)(void* thd,
@@ -69,35 +163,20 @@ void thd_progress_next_stage(void* thd);
 void thd_progress_end(void* thd);
 const char *set_thd_proc_info(void*, const char * info, const char *func,
                               const char *file, unsigned int line);
-extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
-enum thd_kill_levels {
-  THD_IS_NOT_KILLED=0,
-  THD_ABORT_SOFTLY=50,
-  THD_ABORT_ASAP=100,
-};
-extern struct kill_statement_service_st {
-  enum thd_kill_levels (*thd_kill_level_func)(const void*);
-} *thd_kill_statement_service;
-enum thd_kill_levels thd_kill_level(const void*);
-typedef long my_time_t;
-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;
-extern struct thd_timezone_service_st {
-  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
-} *thd_timezone_service;
-my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+extern struct my_sha1_service_st {
+  void (*my_sha1_type)(unsigned char*, const char*, size_t);
+  void (*my_sha1_multi_type)(unsigned char*, ...);
+  size_t (*my_sha1_context_size_type)();
+  void (*my_sha1_init_type)(void *);
+  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
+  void (*my_sha1_result_type)(void *, unsigned char *);
+} *my_sha1_service;
+void my_sha1(unsigned char*, const char*, size_t);
+void my_sha1_multi(unsigned char*, ...);
+size_t my_sha1_context_size();
+void my_sha1_init(void *context);
+void my_sha1_input(void *context, const unsigned char *buf, size_t len);
+void my_sha1_result(void *context, unsigned char *digest);
 extern struct my_sha2_service_st {
   void (*my_sha224_type)(unsigned char*, const char*, size_t);
   void (*my_sha224_multi_type)(unsigned char*, ...);
@@ -148,83 +227,35 @@ size_t my_sha512_context_size();
 void my_sha512_init(void *context);
 void my_sha512_input(void *context, const unsigned char *buf, size_t len);
 void my_sha512_result(void *context, unsigned char *digest);
-extern struct my_sha1_service_st {
-  void (*my_sha1_type)(unsigned char*, const char*, size_t);
-  void (*my_sha1_multi_type)(unsigned char*, ...);
-  size_t (*my_sha1_context_size_type)();
-  void (*my_sha1_init_type)(void *);
-  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
-  void (*my_sha1_result_type)(void *, unsigned char *);
-} *my_sha1_service;
-void my_sha1(unsigned char*, const char*, size_t);
-void my_sha1_multi(unsigned char*, ...);
-size_t my_sha1_context_size();
-void my_sha1_init(void *context);
-void my_sha1_input(void *context, const unsigned char *buf, size_t len);
-void my_sha1_result(void *context, unsigned char *digest);
-extern struct my_md5_service_st {
-  void (*my_md5_type)(unsigned char*, const char*, size_t);
-  void (*my_md5_multi_type)(unsigned char*, ...);
-  size_t (*my_md5_context_size_type)();
-  void (*my_md5_init_type)(void *);
-  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
-  void (*my_md5_result_type)(void *, unsigned char *);
-} *my_md5_service;
-void my_md5(unsigned char*, const char*, size_t);
-void my_md5_multi(unsigned char*, ...);
-size_t my_md5_context_size();
-void my_md5_init(void *context);
-void my_md5_input(void *context, const unsigned char *buf, size_t len);
-void my_md5_result(void *context, unsigned char *digest);
-extern struct base64_service_st {
-  int (*base64_needed_encoded_length_ptr)(int length_of_data);
-  int (*base64_encode_max_arg_length_ptr)(void);
-  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
-  int (*base64_decode_max_arg_length_ptr)();
-  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
-  int (*base64_decode_ptr)(const char *src, size_t src_len,
-                           void *dst, const char **end_ptr, int flags);
-} *base64_service;
-int base64_needed_encoded_length(int length_of_data);
-int base64_encode_max_arg_length(void);
-int base64_needed_decoded_length(int length_of_encoded_data);
-int base64_decode_max_arg_length();
-int base64_encode(const void *src, size_t src_len, char *dst);
-int base64_decode(const char *src, size_t src_len,
-                  void *dst, const char **end_ptr, int flags);
-typedef struct logger_handle_st LOGGER_HANDLE;
-extern struct logger_service_st {
-  void (*logger_init_mutexes)();
-  LOGGER_HANDLE* (*open)(const char *path,
-                         unsigned long long size_limit,
-                         unsigned int rotations);
-  int (*close)(LOGGER_HANDLE *log);
-  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
-  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int (*rotate)(LOGGER_HANDLE *log);
-} *logger_service;
-  void logger_init_mutexes();
-  LOGGER_HANDLE *logger_open(const char *path,
-                             unsigned long long size_limit,
-                             unsigned int rotations);
-  int logger_close(LOGGER_HANDLE *log);
-  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
-  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int logger_rotate(LOGGER_HANDLE *log);
+struct st_mysql_lex_string
+{
+  char *str;
+  size_t length;
+};
+typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
+extern struct thd_alloc_service_st {
+  void *(*thd_alloc_func)(void*, unsigned int);
+  void *(*thd_calloc_func)(void*, unsigned int);
+  char *(*thd_strdup_func)(void*, const char *);
+  char *(*thd_strmake_func)(void*, const char *, unsigned int);
+  void *(*thd_memdup_func)(void*, const void*, unsigned int);
+  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
+                                        const char *, unsigned int, int);
+} *thd_alloc_service;
+void *thd_alloc(void* thd, unsigned int size);
+void *thd_calloc(void* thd, unsigned int size);
+char *thd_strdup(void* thd, const char *str);
+char *thd_strmake(void* thd, const char *str, unsigned int size);
+void *thd_memdup(void* thd, const void* str, unsigned int size);
+MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
+                                      const char *str, unsigned int size,
+                                      int allocate_lex_string);
 extern struct thd_autoinc_service_st {
   void (*thd_get_autoinc_func)(const void* thd,
                                unsigned long* off, unsigned long* inc);
 } *thd_autoinc_service;
 void thd_get_autoinc(const void* thd,
                      unsigned long* off, unsigned long* inc);
-extern struct thd_rnd_service_st {
-  double (*thd_rnd_ptr)(void* thd);
-  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
-} *thd_rnd_service;
-double thd_rnd(void* thd);
-void thd_create_random_password(void* thd, char *to, size_t length);
 extern struct thd_error_context_service_st {
   const char *(*thd_get_error_message_func)(const void* thd);
   unsigned int (*thd_get_error_number_func)(const void* thd);
@@ -242,6 +273,12 @@ void thd_inc_error_row(void* thd);
 char *thd_get_error_context_description(void* thd,
                                         char *buffer, unsigned int length,
                                         unsigned int max_query_length);
+extern struct thd_rnd_service_st {
+  double (*thd_rnd_ptr)(void* thd);
+  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
+} *thd_rnd_service;
+double thd_rnd(void* thd);
+void thd_create_random_password(void* thd, char *to, size_t length);
 typedef int MYSQL_THD_KEY_T;
 extern struct thd_specifics_service_st {
   int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
@@ -253,82 +290,45 @@ int thd_key_create(MYSQL_THD_KEY_T *key);
 void thd_key_delete(MYSQL_THD_KEY_T *key);
 void* thd_getspecific(void* thd, MYSQL_THD_KEY_T key);
 int thd_setspecific(void* thd, MYSQL_THD_KEY_T key, void *value);
-struct encryption_service_st {
-  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
-  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
-                                          unsigned char* buffer, unsigned int* length);
-  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
-  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
-                                  const unsigned char* iv, unsigned int ivlen,
-                                  int flags, unsigned int key_id,
-                                  unsigned int key_version);
-  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
-                                    unsigned char* dst, unsigned int* dlen);
-  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
-  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
-};
-extern struct encryption_service_st encryption_handler;
-static inline unsigned int encryption_key_id_exists(unsigned int id)
-{
-  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
-}
-static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
-{
-  unsigned int unused;
-  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
-}
-static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
-                                   unsigned char* dst, unsigned int* dlen,
-                                   const unsigned char* key, unsigned int klen,
-                                   const unsigned char* iv, unsigned int ivlen,
-                                   int flags, unsigned int key_id, unsigned int key_version)
+typedef long my_time_t;
+enum enum_mysql_timestamp_type
 {
-  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
-  int res1, res2;
-  unsigned int d1, d2;
-  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
-    return res1;
-  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
-  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
-  *dlen= d1 + d2;
-  return res1 ? res1 : res2;
-}
-struct st_encryption_scheme_key {
-  unsigned int version;
-  unsigned char key[16];
-};
-struct st_encryption_scheme {
-  unsigned char iv[16];
-  struct st_encryption_scheme_key key[3];
-  unsigned int keyserver_requests;
-  unsigned int key_id;
-  unsigned int type;
-  void (*locker)(struct st_encryption_scheme *self, int release);
+  MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
+  MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
 };
-extern struct encryption_scheme_service_st {
-  int (*encryption_scheme_encrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-  int (*encryption_scheme_decrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-} *encryption_scheme_service;
-int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
-int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
+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;
+extern struct thd_timezone_service_st {
+  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
+} *thd_timezone_service;
+my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+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_NET= 11,
+  THD_WAIT_LAST= 12
+} 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);
 struct st_mysql_xid {
   long formatID;
   long gtrid_length;

include/mysql/plugin_auth.h.pp

 typedef char my_bool;
 typedef void * MYSQL_PLUGIN;
+extern struct base64_service_st {
+  int (*base64_needed_encoded_length_ptr)(int length_of_data);
+  int (*base64_encode_max_arg_length_ptr)(void);
+  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
+  int (*base64_decode_max_arg_length_ptr)();
+  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
+  int (*base64_decode_ptr)(const char *src, size_t src_len,
+                           void *dst, const char **end_ptr, int flags);
+} *base64_service;
+int base64_needed_encoded_length(int length_of_data);
+int base64_encode_max_arg_length(void);
+int base64_needed_decoded_length(int length_of_encoded_data);
+int base64_decode_max_arg_length();
+int base64_encode(const void *src, size_t src_len, char *dst);
+int base64_decode(const char *src, size_t src_len,
+                  void *dst, const char **end_ptr, int flags);
+extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
+struct encryption_service_st {
+  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
+  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
+                                          unsigned char* buffer, unsigned int* length);
+  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
+  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
+                                  const unsigned char* iv, unsigned int ivlen,
+                                  int flags, unsigned int key_id,
+                                  unsigned int key_version);
+  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
+                                    unsigned char* dst, unsigned int* dlen);
+  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
+  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
+};
+extern struct encryption_service_st encryption_handler;
+static inline unsigned int encryption_key_id_exists(unsigned int id)
+{
+  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
+}
+static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
+{
+  unsigned int unused;
+  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
+}
+static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
+                                   unsigned char* dst, unsigned int* dlen,
+                                   const unsigned char* key, unsigned int klen,
+                                   const unsigned char* iv, unsigned int ivlen,
+                                   int flags, unsigned int key_id, unsigned int key_version)
+{
+  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
+  int res1, res2;
+  unsigned int d1, d2;
+  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
+    return res1;
+  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
+  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
+  *dlen= d1 + d2;
+  return res1 ? res1 : res2;
+}
+struct st_encryption_scheme_key {
+  unsigned int version;
+  unsigned char key[16];
+};
+struct st_encryption_scheme {
+  unsigned char iv[16];
+  struct st_encryption_scheme_key key[3];
+  unsigned int keyserver_requests;
+  unsigned int key_id;
+  unsigned int type;
+  void (*locker)(struct st_encryption_scheme *self, int release);
+};
+extern struct encryption_scheme_service_st {
+  int (*encryption_scheme_encrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+  int (*encryption_scheme_decrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+} *encryption_scheme_service;
+int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+enum thd_kill_levels {
+  THD_IS_NOT_KILLED=0,
+  THD_ABORT_SOFTLY=50,
+  THD_ABORT_ASAP=100,
+};
+extern struct kill_statement_service_st {
+  enum thd_kill_levels (*thd_kill_level_func)(const void*);
+} *thd_kill_statement_service;
+enum thd_kill_levels thd_kill_level(const void*);
+typedef struct logger_handle_st LOGGER_HANDLE;
+extern struct logger_service_st {
+  void (*logger_init_mutexes)();
+  LOGGER_HANDLE* (*open)(const char *path,
+                         unsigned long long size_limit,
+                         unsigned int rotations);
+  int (*close)(LOGGER_HANDLE *log);
+  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
+  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int (*rotate)(LOGGER_HANDLE *log);
+} *logger_service;
+  void logger_init_mutexes();
+  LOGGER_HANDLE *logger_open(const char *path,
+                             unsigned long long size_limit,
+                             unsigned int rotations);
+  int logger_close(LOGGER_HANDLE *log);
+  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
+  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int logger_rotate(LOGGER_HANDLE *log);
+extern struct my_md5_service_st {
+  void (*my_md5_type)(unsigned char*, const char*, size_t);
+  void (*my_md5_multi_type)(unsigned char*, ...);
+  size_t (*my_md5_context_size_type)();
+  void (*my_md5_init_type)(void *);
+  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
+  void (*my_md5_result_type)(void *, unsigned char *);
+} *my_md5_service;
+void my_md5(unsigned char*, const char*, size_t);
+void my_md5_multi(unsigned char*, ...);
+size_t my_md5_context_size();
+void my_md5_init(void *context);
+void my_md5_input(void *context, const unsigned char *buf, size_t len);
+void my_md5_result(void *context, unsigned char *digest);
 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);
-struct st_mysql_lex_string
-{
-  char *str;
-  size_t length;
-};
-typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
-extern struct thd_alloc_service_st {
-  void *(*thd_alloc_func)(void*, unsigned int);
-  void *(*thd_calloc_func)(void*, unsigned int);
-  char *(*thd_strdup_func)(void*, const char *);
-  char *(*thd_strmake_func)(void*, const char *, unsigned int);
-  void *(*thd_memdup_func)(void*, const void*, unsigned int);
-  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
-                                        const char *, unsigned int, int);
-} *thd_alloc_service;
-void *thd_alloc(void* thd, unsigned int size);
-void *thd_calloc(void* thd, unsigned int size);
-char *thd_strdup(void* thd, const char *str);
-char *thd_strmake(void* thd, const char *str, unsigned int size);
-void *thd_memdup(void* thd, const void* str, unsigned int size);
-MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
-                                      const char *str, unsigned int size,
-                                      int allocate_lex_string);
-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_NET= 11,
-  THD_WAIT_LAST= 12
-} 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);
 extern struct progress_report_service_st {
   void (*thd_progress_init_func)(void* thd, unsigned int max_stage);
   void (*thd_progress_report_func)(void* thd,
@@ -69,35 +163,20 @@ void thd_progress_next_stage(void* thd);
 void thd_progress_end(void* thd);
 const char *set_thd_proc_info(void*, const char * info, const char *func,
                               const char *file, unsigned int line);
-extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
-enum thd_kill_levels {
-  THD_IS_NOT_KILLED=0,
-  THD_ABORT_SOFTLY=50,
-  THD_ABORT_ASAP=100,
-};
-extern struct kill_statement_service_st {
-  enum thd_kill_levels (*thd_kill_level_func)(const void*);
-} *thd_kill_statement_service;
-enum thd_kill_levels thd_kill_level(const void*);
-typedef long my_time_t;
-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;
-extern struct thd_timezone_service_st {
-  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
-} *thd_timezone_service;
-my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+extern struct my_sha1_service_st {
+  void (*my_sha1_type)(unsigned char*, const char*, size_t);
+  void (*my_sha1_multi_type)(unsigned char*, ...);
+  size_t (*my_sha1_context_size_type)();
+  void (*my_sha1_init_type)(void *);
+  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
+  void (*my_sha1_result_type)(void *, unsigned char *);
+} *my_sha1_service;
+void my_sha1(unsigned char*, const char*, size_t);
+void my_sha1_multi(unsigned char*, ...);
+size_t my_sha1_context_size();
+void my_sha1_init(void *context);
+void my_sha1_input(void *context, const unsigned char *buf, size_t len);
+void my_sha1_result(void *context, unsigned char *digest);
 extern struct my_sha2_service_st {
   void (*my_sha224_type)(unsigned char*, const char*, size_t);
   void (*my_sha224_multi_type)(unsigned char*, ...);
@@ -148,83 +227,35 @@ size_t my_sha512_context_size();
 void my_sha512_init(void *context);
 void my_sha512_input(void *context, const unsigned char *buf, size_t len);
 void my_sha512_result(void *context, unsigned char *digest);
-extern struct my_sha1_service_st {
-  void (*my_sha1_type)(unsigned char*, const char*, size_t);
-  void (*my_sha1_multi_type)(unsigned char*, ...);
-  size_t (*my_sha1_context_size_type)();
-  void (*my_sha1_init_type)(void *);
-  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
-  void (*my_sha1_result_type)(void *, unsigned char *);
-} *my_sha1_service;
-void my_sha1(unsigned char*, const char*, size_t);
-void my_sha1_multi(unsigned char*, ...);
-size_t my_sha1_context_size();
-void my_sha1_init(void *context);
-void my_sha1_input(void *context, const unsigned char *buf, size_t len);
-void my_sha1_result(void *context, unsigned char *digest);
-extern struct my_md5_service_st {
-  void (*my_md5_type)(unsigned char*, const char*, size_t);
-  void (*my_md5_multi_type)(unsigned char*, ...);
-  size_t (*my_md5_context_size_type)();
-  void (*my_md5_init_type)(void *);
-  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
-  void (*my_md5_result_type)(void *, unsigned char *);
-} *my_md5_service;
-void my_md5(unsigned char*, const char*, size_t);
-void my_md5_multi(unsigned char*, ...);
-size_t my_md5_context_size();
-void my_md5_init(void *context);
-void my_md5_input(void *context, const unsigned char *buf, size_t len);
-void my_md5_result(void *context, unsigned char *digest);
-extern struct base64_service_st {
-  int (*base64_needed_encoded_length_ptr)(int length_of_data);
-  int (*base64_encode_max_arg_length_ptr)(void);
-  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
-  int (*base64_decode_max_arg_length_ptr)();
-  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
-  int (*base64_decode_ptr)(const char *src, size_t src_len,
-                           void *dst, const char **end_ptr, int flags);
-} *base64_service;
-int base64_needed_encoded_length(int length_of_data);
-int base64_encode_max_arg_length(void);
-int base64_needed_decoded_length(int length_of_encoded_data);
-int base64_decode_max_arg_length();
-int base64_encode(const void *src, size_t src_len, char *dst);
-int base64_decode(const char *src, size_t src_len,
-                  void *dst, const char **end_ptr, int flags);
-typedef struct logger_handle_st LOGGER_HANDLE;
-extern struct logger_service_st {
-  void (*logger_init_mutexes)();
-  LOGGER_HANDLE* (*open)(const char *path,
-                         unsigned long long size_limit,
-                         unsigned int rotations);
-  int (*close)(LOGGER_HANDLE *log);
-  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
-  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int (*rotate)(LOGGER_HANDLE *log);
-} *logger_service;
-  void logger_init_mutexes();
-  LOGGER_HANDLE *logger_open(const char *path,
-                             unsigned long long size_limit,
-                             unsigned int rotations);
-  int logger_close(LOGGER_HANDLE *log);
-  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
-  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int logger_rotate(LOGGER_HANDLE *log);
+struct st_mysql_lex_string
+{
+  char *str;
+  size_t length;
+};
+typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
+extern struct thd_alloc_service_st {
+  void *(*thd_alloc_func)(void*, unsigned int);
+  void *(*thd_calloc_func)(void*, unsigned int);
+  char *(*thd_strdup_func)(void*, const char *);
+  char *(*thd_strmake_func)(void*, const char *, unsigned int);
+  void *(*thd_memdup_func)(void*, const void*, unsigned int);
+  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
+                                        const char *, unsigned int, int);
+} *thd_alloc_service;
+void *thd_alloc(void* thd, unsigned int size);
+void *thd_calloc(void* thd, unsigned int size);
+char *thd_strdup(void* thd, const char *str);
+char *thd_strmake(void* thd, const char *str, unsigned int size);
+void *thd_memdup(void* thd, const void* str, unsigned int size);
+MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
+                                      const char *str, unsigned int size,
+                                      int allocate_lex_string);
 extern struct thd_autoinc_service_st {
   void (*thd_get_autoinc_func)(const void* thd,
                                unsigned long* off, unsigned long* inc);
 } *thd_autoinc_service;
 void thd_get_autoinc(const void* thd,
                      unsigned long* off, unsigned long* inc);
-extern struct thd_rnd_service_st {
-  double (*thd_rnd_ptr)(void* thd);
-  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
-} *thd_rnd_service;
-double thd_rnd(void* thd);
-void thd_create_random_password(void* thd, char *to, size_t length);
 extern struct thd_error_context_service_st {
   const char *(*thd_get_error_message_func)(const void* thd);
   unsigned int (*thd_get_error_number_func)(const void* thd);
@@ -242,6 +273,12 @@ void thd_inc_error_row(void* thd);
 char *thd_get_error_context_description(void* thd,
                                         char *buffer, unsigned int length,
                                         unsigned int max_query_length);
+extern struct thd_rnd_service_st {
+  double (*thd_rnd_ptr)(void* thd);
+  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
+} *thd_rnd_service;
+double thd_rnd(void* thd);
+void thd_create_random_password(void* thd, char *to, size_t length);
 typedef int MYSQL_THD_KEY_T;
 extern struct thd_specifics_service_st {
   int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
@@ -253,82 +290,45 @@ int thd_key_create(MYSQL_THD_KEY_T *key);
 void thd_key_delete(MYSQL_THD_KEY_T *key);
 void* thd_getspecific(void* thd, MYSQL_THD_KEY_T key);
 int thd_setspecific(void* thd, MYSQL_THD_KEY_T key, void *value);
-struct encryption_service_st {
-  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
-  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
-                                          unsigned char* buffer, unsigned int* length);
-  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
-  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
-                                  const unsigned char* iv, unsigned int ivlen,
-                                  int flags, unsigned int key_id,
-                                  unsigned int key_version);
-  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
-                                    unsigned char* dst, unsigned int* dlen);
-  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
-  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
-};
-extern struct encryption_service_st encryption_handler;
-static inline unsigned int encryption_key_id_exists(unsigned int id)
-{
-  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
-}
-static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
-{
-  unsigned int unused;
-  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
-}
-static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
-                                   unsigned char* dst, unsigned int* dlen,
-                                   const unsigned char* key, unsigned int klen,
-                                   const unsigned char* iv, unsigned int ivlen,
-                                   int flags, unsigned int key_id, unsigned int key_version)
+typedef long my_time_t;
+enum enum_mysql_timestamp_type
 {
-  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
-  int res1, res2;
-  unsigned int d1, d2;
-  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
-    return res1;
-  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
-  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
-  *dlen= d1 + d2;
-  return res1 ? res1 : res2;
-}
-struct st_encryption_scheme_key {
-  unsigned int version;
-  unsigned char key[16];
-};
-struct st_encryption_scheme {
-  unsigned char iv[16];
-  struct st_encryption_scheme_key key[3];
-  unsigned int keyserver_requests;
-  unsigned int key_id;
-  unsigned int type;
-  void (*locker)(struct st_encryption_scheme *self, int release);
+  MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
+  MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
 };
-extern struct encryption_scheme_service_st {
-  int (*encryption_scheme_encrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-  int (*encryption_scheme_decrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-} *encryption_scheme_service;
-int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
-int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
+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;
+extern struct thd_timezone_service_st {
+  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
+} *thd_timezone_service;
+my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+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_NET= 11,
+  THD_WAIT_LAST= 12
+} 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);
 struct st_mysql_xid {
   long formatID;
   long gtrid_length;

include/mysql/plugin_encryption.h.pp

 typedef char my_bool;
 typedef void * MYSQL_PLUGIN;
+extern struct base64_service_st {
+  int (*base64_needed_encoded_length_ptr)(int length_of_data);
+  int (*base64_encode_max_arg_length_ptr)(void);
+  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
+  int (*base64_decode_max_arg_length_ptr)();
+  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
+  int (*base64_decode_ptr)(const char *src, size_t src_len,
+                           void *dst, const char **end_ptr, int flags);
+} *base64_service;
+int base64_needed_encoded_length(int length_of_data);
+int base64_encode_max_arg_length(void);
+int base64_needed_decoded_length(int length_of_encoded_data);
+int base64_decode_max_arg_length();
+int base64_encode(const void *src, size_t src_len, char *dst);
+int base64_decode(const char *src, size_t src_len,
+                  void *dst, const char **end_ptr, int flags);
+extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
+struct encryption_service_st {
+  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
+  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
+                                          unsigned char* buffer, unsigned int* length);
+  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
+  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
+                                  const unsigned char* iv, unsigned int ivlen,
+                                  int flags, unsigned int key_id,
+                                  unsigned int key_version);
+  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
+                                    unsigned char* dst, unsigned int* dlen);
+  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
+  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
+};
+extern struct encryption_service_st encryption_handler;
+static inline unsigned int encryption_key_id_exists(unsigned int id)
+{
+  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
+}
+static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
+{
+  unsigned int unused;
+  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
+}
+static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
+                                   unsigned char* dst, unsigned int* dlen,
+                                   const unsigned char* key, unsigned int klen,
+                                   const unsigned char* iv, unsigned int ivlen,
+                                   int flags, unsigned int key_id, unsigned int key_version)
+{
+  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
+  int res1, res2;
+  unsigned int d1, d2;
+  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
+    return res1;
+  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
+  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
+  *dlen= d1 + d2;
+  return res1 ? res1 : res2;
+}
+struct st_encryption_scheme_key {
+  unsigned int version;
+  unsigned char key[16];
+};
+struct st_encryption_scheme {
+  unsigned char iv[16];
+  struct st_encryption_scheme_key key[3];
+  unsigned int keyserver_requests;
+  unsigned int key_id;
+  unsigned int type;
+  void (*locker)(struct st_encryption_scheme *self, int release);
+};
+extern struct encryption_scheme_service_st {
+  int (*encryption_scheme_encrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+  int (*encryption_scheme_decrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+} *encryption_scheme_service;
+int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+enum thd_kill_levels {
+  THD_IS_NOT_KILLED=0,
+  THD_ABORT_SOFTLY=50,
+  THD_ABORT_ASAP=100,
+};
+extern struct kill_statement_service_st {
+  enum thd_kill_levels (*thd_kill_level_func)(const void*);
+} *thd_kill_statement_service;
+enum thd_kill_levels thd_kill_level(const void*);
+typedef struct logger_handle_st LOGGER_HANDLE;
+extern struct logger_service_st {
+  void (*logger_init_mutexes)();
+  LOGGER_HANDLE* (*open)(const char *path,
+                         unsigned long long size_limit,
+                         unsigned int rotations);
+  int (*close)(LOGGER_HANDLE *log);
+  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
+  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int (*rotate)(LOGGER_HANDLE *log);
+} *logger_service;
+  void logger_init_mutexes();
+  LOGGER_HANDLE *logger_open(const char *path,
+                             unsigned long long size_limit,
+                             unsigned int rotations);
+  int logger_close(LOGGER_HANDLE *log);
+  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
+  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int logger_rotate(LOGGER_HANDLE *log);
+extern struct my_md5_service_st {
+  void (*my_md5_type)(unsigned char*, const char*, size_t);
+  void (*my_md5_multi_type)(unsigned char*, ...);
+  size_t (*my_md5_context_size_type)();
+  void (*my_md5_init_type)(void *);
+  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
+  void (*my_md5_result_type)(void *, unsigned char *);
+} *my_md5_service;
+void my_md5(unsigned char*, const char*, size_t);
+void my_md5_multi(unsigned char*, ...);
+size_t my_md5_context_size();
+void my_md5_init(void *context);
+void my_md5_input(void *context, const unsigned char *buf, size_t len);
+void my_md5_result(void *context, unsigned char *digest);
 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);
-struct st_mysql_lex_string
-{
-  char *str;
-  size_t length;
-};
-typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
-extern struct thd_alloc_service_st {
-  void *(*thd_alloc_func)(void*, unsigned int);
-  void *(*thd_calloc_func)(void*, unsigned int);
-  char *(*thd_strdup_func)(void*, const char *);
-  char *(*thd_strmake_func)(void*, const char *, unsigned int);
-  void *(*thd_memdup_func)(void*, const void*, unsigned int);
-  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
-                                        const char *, unsigned int, int);
-} *thd_alloc_service;
-void *thd_alloc(void* thd, unsigned int size);
-void *thd_calloc(void* thd, unsigned int size);
-char *thd_strdup(void* thd, const char *str);
-char *thd_strmake(void* thd, const char *str, unsigned int size);
-void *thd_memdup(void* thd, const void* str, unsigned int size);
-MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
-                                      const char *str, unsigned int size,
-                                      int allocate_lex_string);
-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_NET= 11,
-  THD_WAIT_LAST= 12
-} 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);
 extern struct progress_report_service_st {
   void (*thd_progress_init_func)(void* thd, unsigned int max_stage);
   void (*thd_progress_report_func)(void* thd,
@@ -69,35 +163,20 @@ void thd_progress_next_stage(void* thd);
 void thd_progress_end(void* thd);
 const char *set_thd_proc_info(void*, const char * info, const char *func,
                               const char *file, unsigned int line);
-extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
-enum thd_kill_levels {
-  THD_IS_NOT_KILLED=0,
-  THD_ABORT_SOFTLY=50,
-  THD_ABORT_ASAP=100,
-};
-extern struct kill_statement_service_st {
-  enum thd_kill_levels (*thd_kill_level_func)(const void*);
-} *thd_kill_statement_service;
-enum thd_kill_levels thd_kill_level(const void*);
-typedef long my_time_t;
-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;
-extern struct thd_timezone_service_st {
-  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
-} *thd_timezone_service;
-my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+extern struct my_sha1_service_st {
+  void (*my_sha1_type)(unsigned char*, const char*, size_t);
+  void (*my_sha1_multi_type)(unsigned char*, ...);
+  size_t (*my_sha1_context_size_type)();
+  void (*my_sha1_init_type)(void *);
+  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
+  void (*my_sha1_result_type)(void *, unsigned char *);
+} *my_sha1_service;
+void my_sha1(unsigned char*, const char*, size_t);
+void my_sha1_multi(unsigned char*, ...);
+size_t my_sha1_context_size();
+void my_sha1_init(void *context);
+void my_sha1_input(void *context, const unsigned char *buf, size_t len);
+void my_sha1_result(void *context, unsigned char *digest);
 extern struct my_sha2_service_st {
   void (*my_sha224_type)(unsigned char*, const char*, size_t);
   void (*my_sha224_multi_type)(unsigned char*, ...);
@@ -148,83 +227,35 @@ size_t my_sha512_context_size();
 void my_sha512_init(void *context);
 void my_sha512_input(void *context, const unsigned char *buf, size_t len);
 void my_sha512_result(void *context, unsigned char *digest);
-extern struct my_sha1_service_st {
-  void (*my_sha1_type)(unsigned char*, const char*, size_t);
-  void (*my_sha1_multi_type)(unsigned char*, ...);
-  size_t (*my_sha1_context_size_type)();
-  void (*my_sha1_init_type)(void *);
-  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
-  void (*my_sha1_result_type)(void *, unsigned char *);
-} *my_sha1_service;
-void my_sha1(unsigned char*, const char*, size_t);
-void my_sha1_multi(unsigned char*, ...);
-size_t my_sha1_context_size();
-void my_sha1_init(void *context);
-void my_sha1_input(void *context, const unsigned char *buf, size_t len);
-void my_sha1_result(void *context, unsigned char *digest);
-extern struct my_md5_service_st {
-  void (*my_md5_type)(unsigned char*, const char*, size_t);
-  void (*my_md5_multi_type)(unsigned char*, ...);
-  size_t (*my_md5_context_size_type)();
-  void (*my_md5_init_type)(void *);
-  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
-  void (*my_md5_result_type)(void *, unsigned char *);
-} *my_md5_service;
-void my_md5(unsigned char*, const char*, size_t);
-void my_md5_multi(unsigned char*, ...);
-size_t my_md5_context_size();
-void my_md5_init(void *context);
-void my_md5_input(void *context, const unsigned char *buf, size_t len);
-void my_md5_result(void *context, unsigned char *digest);
-extern struct base64_service_st {
-  int (*base64_needed_encoded_length_ptr)(int length_of_data);
-  int (*base64_encode_max_arg_length_ptr)(void);
-  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
-  int (*base64_decode_max_arg_length_ptr)();
-  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
-  int (*base64_decode_ptr)(const char *src, size_t src_len,
-                           void *dst, const char **end_ptr, int flags);
-} *base64_service;
-int base64_needed_encoded_length(int length_of_data);
-int base64_encode_max_arg_length(void);
-int base64_needed_decoded_length(int length_of_encoded_data);
-int base64_decode_max_arg_length();
-int base64_encode(const void *src, size_t src_len, char *dst);
-int base64_decode(const char *src, size_t src_len,
-                  void *dst, const char **end_ptr, int flags);
-typedef struct logger_handle_st LOGGER_HANDLE;
-extern struct logger_service_st {
-  void (*logger_init_mutexes)();
-  LOGGER_HANDLE* (*open)(const char *path,
-                         unsigned long long size_limit,
-                         unsigned int rotations);
-  int (*close)(LOGGER_HANDLE *log);
-  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
-  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int (*rotate)(LOGGER_HANDLE *log);
-} *logger_service;
-  void logger_init_mutexes();
-  LOGGER_HANDLE *logger_open(const char *path,
-                             unsigned long long size_limit,
-                             unsigned int rotations);
-  int logger_close(LOGGER_HANDLE *log);
-  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
-  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int logger_rotate(LOGGER_HANDLE *log);
+struct st_mysql_lex_string
+{
+  char *str;
+  size_t length;
+};
+typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
+extern struct thd_alloc_service_st {
+  void *(*thd_alloc_func)(void*, unsigned int);
+  void *(*thd_calloc_func)(void*, unsigned int);
+  char *(*thd_strdup_func)(void*, const char *);
+  char *(*thd_strmake_func)(void*, const char *, unsigned int);
+  void *(*thd_memdup_func)(void*, const void*, unsigned int);
+  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
+                                        const char *, unsigned int, int);
+} *thd_alloc_service;
+void *thd_alloc(void* thd, unsigned int size);
+void *thd_calloc(void* thd, unsigned int size);
+char *thd_strdup(void* thd, const char *str);
+char *thd_strmake(void* thd, const char *str, unsigned int size);
+void *thd_memdup(void* thd, const void* str, unsigned int size);
+MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
+                                      const char *str, unsigned int size,
+                                      int allocate_lex_string);
 extern struct thd_autoinc_service_st {
   void (*thd_get_autoinc_func)(const void* thd,
                                unsigned long* off, unsigned long* inc);
 } *thd_autoinc_service;
 void thd_get_autoinc(const void* thd,
                      unsigned long* off, unsigned long* inc);
-extern struct thd_rnd_service_st {
-  double (*thd_rnd_ptr)(void* thd);
-  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
-} *thd_rnd_service;
-double thd_rnd(void* thd);
-void thd_create_random_password(void* thd, char *to, size_t length);
 extern struct thd_error_context_service_st {
   const char *(*thd_get_error_message_func)(const void* thd);
   unsigned int (*thd_get_error_number_func)(const void* thd);
@@ -242,6 +273,12 @@ void thd_inc_error_row(void* thd);
 char *thd_get_error_context_description(void* thd,
                                         char *buffer, unsigned int length,
                                         unsigned int max_query_length);
+extern struct thd_rnd_service_st {
+  double (*thd_rnd_ptr)(void* thd);
+  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
+} *thd_rnd_service;
+double thd_rnd(void* thd);
+void thd_create_random_password(void* thd, char *to, size_t length);
 typedef int MYSQL_THD_KEY_T;
 extern struct thd_specifics_service_st {
   int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
@@ -253,82 +290,45 @@ int thd_key_create(MYSQL_THD_KEY_T *key);
 void thd_key_delete(MYSQL_THD_KEY_T *key);
 void* thd_getspecific(void* thd, MYSQL_THD_KEY_T key);
 int thd_setspecific(void* thd, MYSQL_THD_KEY_T key, void *value);
-struct encryption_service_st {
-  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
-  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
-                                          unsigned char* buffer, unsigned int* length);
-  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
-  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
-                                  const unsigned char* iv, unsigned int ivlen,
-                                  int flags, unsigned int key_id,
-                                  unsigned int key_version);
-  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
-                                    unsigned char* dst, unsigned int* dlen);
-  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
-  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
-};
-extern struct encryption_service_st encryption_handler;
-static inline unsigned int encryption_key_id_exists(unsigned int id)
-{
-  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
-}
-static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
-{
-  unsigned int unused;
-  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
-}
-static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
-                                   unsigned char* dst, unsigned int* dlen,
-                                   const unsigned char* key, unsigned int klen,
-                                   const unsigned char* iv, unsigned int ivlen,
-                                   int flags, unsigned int key_id, unsigned int key_version)
+typedef long my_time_t;
+enum enum_mysql_timestamp_type
 {
-  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
-  int res1, res2;
-  unsigned int d1, d2;
-  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
-    return res1;
-  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
-  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
-  *dlen= d1 + d2;
-  return res1 ? res1 : res2;
-}
-struct st_encryption_scheme_key {
-  unsigned int version;
-  unsigned char key[16];
-};
-struct st_encryption_scheme {
-  unsigned char iv[16];
-  struct st_encryption_scheme_key key[3];
-  unsigned int keyserver_requests;
-  unsigned int key_id;
-  unsigned int type;
-  void (*locker)(struct st_encryption_scheme *self, int release);
+  MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
+  MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
 };
-extern struct encryption_scheme_service_st {
-  int (*encryption_scheme_encrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-  int (*encryption_scheme_decrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-} *encryption_scheme_service;
-int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
-int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
+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;
+extern struct thd_timezone_service_st {
+  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
+} *thd_timezone_service;
+my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+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_NET= 11,
+  THD_WAIT_LAST= 12
+} 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);
 struct st_mysql_xid {
   long formatID;
   long gtrid_length;

include/mysql/plugin_ftparser.h.pp

 typedef char my_bool;
 typedef void * MYSQL_PLUGIN;
+extern struct base64_service_st {
+  int (*base64_needed_encoded_length_ptr)(int length_of_data);
+  int (*base64_encode_max_arg_length_ptr)(void);
+  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
+  int (*base64_decode_max_arg_length_ptr)();
+  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
+  int (*base64_decode_ptr)(const char *src, size_t src_len,
+                           void *dst, const char **end_ptr, int flags);
+} *base64_service;
+int base64_needed_encoded_length(int length_of_data);
+int base64_encode_max_arg_length(void);
+int base64_needed_decoded_length(int length_of_encoded_data);
+int base64_decode_max_arg_length();
+int base64_encode(const void *src, size_t src_len, char *dst);
+int base64_decode(const char *src, size_t src_len,
+                  void *dst, const char **end_ptr, int flags);
+extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
+struct encryption_service_st {
+  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
+  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
+                                          unsigned char* buffer, unsigned int* length);
+  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
+  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
+                                  const unsigned char* iv, unsigned int ivlen,
+                                  int flags, unsigned int key_id,
+                                  unsigned int key_version);
+  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
+                                    unsigned char* dst, unsigned int* dlen);
+  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
+  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
+};
+extern struct encryption_service_st encryption_handler;
+static inline unsigned int encryption_key_id_exists(unsigned int id)
+{
+  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
+}
+static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
+{
+  unsigned int unused;
+  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
+}
+static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
+                                   unsigned char* dst, unsigned int* dlen,
+                                   const unsigned char* key, unsigned int klen,
+                                   const unsigned char* iv, unsigned int ivlen,
+                                   int flags, unsigned int key_id, unsigned int key_version)
+{
+  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
+  int res1, res2;
+  unsigned int d1, d2;
+  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
+    return res1;
+  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
+  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
+  *dlen= d1 + d2;
+  return res1 ? res1 : res2;
+}
+struct st_encryption_scheme_key {
+  unsigned int version;
+  unsigned char key[16];
+};
+struct st_encryption_scheme {
+  unsigned char iv[16];
+  struct st_encryption_scheme_key key[3];
+  unsigned int keyserver_requests;
+  unsigned int key_id;
+  unsigned int type;
+  void (*locker)(struct st_encryption_scheme *self, int release);
+};
+extern struct encryption_scheme_service_st {
+  int (*encryption_scheme_encrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+  int (*encryption_scheme_decrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+} *encryption_scheme_service;
+int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+enum thd_kill_levels {
+  THD_IS_NOT_KILLED=0,
+  THD_ABORT_SOFTLY=50,
+  THD_ABORT_ASAP=100,
+};
+extern struct kill_statement_service_st {
+  enum thd_kill_levels (*thd_kill_level_func)(const void*);
+} *thd_kill_statement_service;
+enum thd_kill_levels thd_kill_level(const void*);
+typedef struct logger_handle_st LOGGER_HANDLE;
+extern struct logger_service_st {
+  void (*logger_init_mutexes)();
+  LOGGER_HANDLE* (*open)(const char *path,
+                         unsigned long long size_limit,
+                         unsigned int rotations);
+  int (*close)(LOGGER_HANDLE *log);
+  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
+  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int (*rotate)(LOGGER_HANDLE *log);
+} *logger_service;
+  void logger_init_mutexes();
+  LOGGER_HANDLE *logger_open(const char *path,
+                             unsigned long long size_limit,
+                             unsigned int rotations);
+  int logger_close(LOGGER_HANDLE *log);
+  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
+  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int logger_rotate(LOGGER_HANDLE *log);
+extern struct my_md5_service_st {
+  void (*my_md5_type)(unsigned char*, const char*, size_t);
+  void (*my_md5_multi_type)(unsigned char*, ...);
+  size_t (*my_md5_context_size_type)();
+  void (*my_md5_init_type)(void *);
+  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
+  void (*my_md5_result_type)(void *, unsigned char *);
+} *my_md5_service;
+void my_md5(unsigned char*, const char*, size_t);
+void my_md5_multi(unsigned char*, ...);
+size_t my_md5_context_size();
+void my_md5_init(void *context);
+void my_md5_input(void *context, const unsigned char *buf, size_t len);
+void my_md5_result(void *context, unsigned char *digest);
 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);
-struct st_mysql_lex_string
-{
-  char *str;
-  size_t length;
-};
-typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
-extern struct thd_alloc_service_st {
-  void *(*thd_alloc_func)(void*, unsigned int);
-  void *(*thd_calloc_func)(void*, unsigned int);
-  char *(*thd_strdup_func)(void*, const char *);
-  char *(*thd_strmake_func)(void*, const char *, unsigned int);
-  void *(*thd_memdup_func)(void*, const void*, unsigned int);
-  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
-                                        const char *, unsigned int, int);
-} *thd_alloc_service;
-void *thd_alloc(void* thd, unsigned int size);
-void *thd_calloc(void* thd, unsigned int size);
-char *thd_strdup(void* thd, const char *str);
-char *thd_strmake(void* thd, const char *str, unsigned int size);
-void *thd_memdup(void* thd, const void* str, unsigned int size);
-MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
-                                      const char *str, unsigned int size,
-                                      int allocate_lex_string);
-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_NET= 11,
-  THD_WAIT_LAST= 12
-} 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);
 extern struct progress_report_service_st {
   void (*thd_progress_init_func)(void* thd, unsigned int max_stage);
   void (*thd_progress_report_func)(void* thd,
@@ -69,35 +163,20 @@ void thd_progress_next_stage(void* thd);
 void thd_progress_end(void* thd);
 const char *set_thd_proc_info(void*, const char * info, const char *func,
                               const char *file, unsigned int line);
-extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
-enum thd_kill_levels {
-  THD_IS_NOT_KILLED=0,
-  THD_ABORT_SOFTLY=50,
-  THD_ABORT_ASAP=100,
-};
-extern struct kill_statement_service_st {
-  enum thd_kill_levels (*thd_kill_level_func)(const void*);
-} *thd_kill_statement_service;
-enum thd_kill_levels thd_kill_level(const void*);
-typedef long my_time_t;
-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;
-extern struct thd_timezone_service_st {
-  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
-} *thd_timezone_service;
-my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+extern struct my_sha1_service_st {
+  void (*my_sha1_type)(unsigned char*, const char*, size_t);
+  void (*my_sha1_multi_type)(unsigned char*, ...);
+  size_t (*my_sha1_context_size_type)();
+  void (*my_sha1_init_type)(void *);
+  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
+  void (*my_sha1_result_type)(void *, unsigned char *);
+} *my_sha1_service;
+void my_sha1(unsigned char*, const char*, size_t);
+void my_sha1_multi(unsigned char*, ...);
+size_t my_sha1_context_size();
+void my_sha1_init(void *context);
+void my_sha1_input(void *context, const unsigned char *buf, size_t len);
+void my_sha1_result(void *context, unsigned char *digest);
 extern struct my_sha2_service_st {
   void (*my_sha224_type)(unsigned char*, const char*, size_t);
   void (*my_sha224_multi_type)(unsigned char*, ...);
@@ -148,83 +227,35 @@ size_t my_sha512_context_size();
 void my_sha512_init(void *context);
 void my_sha512_input(void *context, const unsigned char *buf, size_t len);
 void my_sha512_result(void *context, unsigned char *digest);
-extern struct my_sha1_service_st {
-  void (*my_sha1_type)(unsigned char*, const char*, size_t);
-  void (*my_sha1_multi_type)(unsigned char*, ...);
-  size_t (*my_sha1_context_size_type)();
-  void (*my_sha1_init_type)(void *);
-  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
-  void (*my_sha1_result_type)(void *, unsigned char *);
-} *my_sha1_service;
-void my_sha1(unsigned char*, const char*, size_t);
-void my_sha1_multi(unsigned char*, ...);
-size_t my_sha1_context_size();
-void my_sha1_init(void *context);
-void my_sha1_input(void *context, const unsigned char *buf, size_t len);
-void my_sha1_result(void *context, unsigned char *digest);
-extern struct my_md5_service_st {
-  void (*my_md5_type)(unsigned char*, const char*, size_t);
-  void (*my_md5_multi_type)(unsigned char*, ...);
-  size_t (*my_md5_context_size_type)();
-  void (*my_md5_init_type)(void *);
-  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
-  void (*my_md5_result_type)(void *, unsigned char *);
-} *my_md5_service;
-void my_md5(unsigned char*, const char*, size_t);
-void my_md5_multi(unsigned char*, ...);
-size_t my_md5_context_size();
-void my_md5_init(void *context);
-void my_md5_input(void *context, const unsigned char *buf, size_t len);
-void my_md5_result(void *context, unsigned char *digest);
-extern struct base64_service_st {
-  int (*base64_needed_encoded_length_ptr)(int length_of_data);
-  int (*base64_encode_max_arg_length_ptr)(void);
-  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
-  int (*base64_decode_max_arg_length_ptr)();
-  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
-  int (*base64_decode_ptr)(const char *src, size_t src_len,
-                           void *dst, const char **end_ptr, int flags);
-} *base64_service;
-int base64_needed_encoded_length(int length_of_data);
-int base64_encode_max_arg_length(void);
-int base64_needed_decoded_length(int length_of_encoded_data);
-int base64_decode_max_arg_length();
-int base64_encode(const void *src, size_t src_len, char *dst);
-int base64_decode(const char *src, size_t src_len,
-                  void *dst, const char **end_ptr, int flags);
-typedef struct logger_handle_st LOGGER_HANDLE;
-extern struct logger_service_st {
-  void (*logger_init_mutexes)();
-  LOGGER_HANDLE* (*open)(const char *path,
-                         unsigned long long size_limit,
-                         unsigned int rotations);
-  int (*close)(LOGGER_HANDLE *log);
-  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
-  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int (*rotate)(LOGGER_HANDLE *log);
-} *logger_service;
-  void logger_init_mutexes();
-  LOGGER_HANDLE *logger_open(const char *path,
-                             unsigned long long size_limit,
-                             unsigned int rotations);
-  int logger_close(LOGGER_HANDLE *log);
-  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
-  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int logger_rotate(LOGGER_HANDLE *log);
+struct st_mysql_lex_string
+{
+  char *str;
+  size_t length;
+};
+typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
+extern struct thd_alloc_service_st {
+  void *(*thd_alloc_func)(void*, unsigned int);
+  void *(*thd_calloc_func)(void*, unsigned int);
+  char *(*thd_strdup_func)(void*, const char *);
+  char *(*thd_strmake_func)(void*, const char *, unsigned int);
+  void *(*thd_memdup_func)(void*, const void*, unsigned int);
+  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
+                                        const char *, unsigned int, int);
+} *thd_alloc_service;
+void *thd_alloc(void* thd, unsigned int size);
+void *thd_calloc(void* thd, unsigned int size);
+char *thd_strdup(void* thd, const char *str);
+char *thd_strmake(void* thd, const char *str, unsigned int size);
+void *thd_memdup(void* thd, const void* str, unsigned int size);
+MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
+                                      const char *str, unsigned int size,
+                                      int allocate_lex_string);
 extern struct thd_autoinc_service_st {
   void (*thd_get_autoinc_func)(const void* thd,
                                unsigned long* off, unsigned long* inc);
 } *thd_autoinc_service;
 void thd_get_autoinc(const void* thd,
                      unsigned long* off, unsigned long* inc);
-extern struct thd_rnd_service_st {
-  double (*thd_rnd_ptr)(void* thd);
-  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
-} *thd_rnd_service;
-double thd_rnd(void* thd);
-void thd_create_random_password(void* thd, char *to, size_t length);
 extern struct thd_error_context_service_st {
   const char *(*thd_get_error_message_func)(const void* thd);
   unsigned int (*thd_get_error_number_func)(const void* thd);
@@ -242,6 +273,12 @@ void thd_inc_error_row(void* thd);
 char *thd_get_error_context_description(void* thd,
                                         char *buffer, unsigned int length,
                                         unsigned int max_query_length);
+extern struct thd_rnd_service_st {
+  double (*thd_rnd_ptr)(void* thd);
+  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
+} *thd_rnd_service;
+double thd_rnd(void* thd);
+void thd_create_random_password(void* thd, char *to, size_t length);
 typedef int MYSQL_THD_KEY_T;
 extern struct thd_specifics_service_st {
   int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
@@ -253,82 +290,45 @@ int thd_key_create(MYSQL_THD_KEY_T *key);
 void thd_key_delete(MYSQL_THD_KEY_T *key);
 void* thd_getspecific(void* thd, MYSQL_THD_KEY_T key);
 int thd_setspecific(void* thd, MYSQL_THD_KEY_T key, void *value);
-struct encryption_service_st {
-  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
-  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
-                                          unsigned char* buffer, unsigned int* length);
-  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
-  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
-                                  const unsigned char* iv, unsigned int ivlen,
-                                  int flags, unsigned int key_id,
-                                  unsigned int key_version);
-  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
-                                    unsigned char* dst, unsigned int* dlen);
-  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
-  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
-};
-extern struct encryption_service_st encryption_handler;
-static inline unsigned int encryption_key_id_exists(unsigned int id)
-{
-  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
-}
-static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
-{
-  unsigned int unused;
-  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
-}
-static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
-                                   unsigned char* dst, unsigned int* dlen,
-                                   const unsigned char* key, unsigned int klen,
-                                   const unsigned char* iv, unsigned int ivlen,
-                                   int flags, unsigned int key_id, unsigned int key_version)
+typedef long my_time_t;
+enum enum_mysql_timestamp_type
 {
-  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
-  int res1, res2;
-  unsigned int d1, d2;
-  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
-    return res1;
-  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
-  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
-  *dlen= d1 + d2;
-  return res1 ? res1 : res2;
-}
-struct st_encryption_scheme_key {
-  unsigned int version;
-  unsigned char key[16];
-};
-struct st_encryption_scheme {
-  unsigned char iv[16];
-  struct st_encryption_scheme_key key[3];
-  unsigned int keyserver_requests;
-  unsigned int key_id;
-  unsigned int type;
-  void (*locker)(struct st_encryption_scheme *self, int release);
+  MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
+  MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
 };
-extern struct encryption_scheme_service_st {
-  int (*encryption_scheme_encrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-  int (*encryption_scheme_decrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-} *encryption_scheme_service;
-int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
-int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
+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;
+extern struct thd_timezone_service_st {
+  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
+} *thd_timezone_service;
+my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+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_NET= 11,
+  THD_WAIT_LAST= 12
+} 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);
 struct st_mysql_xid {
   long formatID;
   long gtrid_length;

include/mysql/plugin_password_validation.h.pp

 typedef char my_bool;
 typedef void * MYSQL_PLUGIN;
+extern struct base64_service_st {
+  int (*base64_needed_encoded_length_ptr)(int length_of_data);
+  int (*base64_encode_max_arg_length_ptr)(void);
+  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
+  int (*base64_decode_max_arg_length_ptr)();
+  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
+  int (*base64_decode_ptr)(const char *src, size_t src_len,
+                           void *dst, const char **end_ptr, int flags);
+} *base64_service;
+int base64_needed_encoded_length(int length_of_data);
+int base64_encode_max_arg_length(void);
+int base64_needed_decoded_length(int length_of_encoded_data);
+int base64_decode_max_arg_length();
+int base64_encode(const void *src, size_t src_len, char *dst);
+int base64_decode(const char *src, size_t src_len,
+                  void *dst, const char **end_ptr, int flags);
+extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
+struct encryption_service_st {
+  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
+  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
+                                          unsigned char* buffer, unsigned int* length);
+  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
+  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
+                                  const unsigned char* iv, unsigned int ivlen,
+                                  int flags, unsigned int key_id,
+                                  unsigned int key_version);
+  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
+                                    unsigned char* dst, unsigned int* dlen);
+  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
+  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
+};
+extern struct encryption_service_st encryption_handler;
+static inline unsigned int encryption_key_id_exists(unsigned int id)
+{
+  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
+}
+static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
+{
+  unsigned int unused;
+  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
+}
+static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
+                                   unsigned char* dst, unsigned int* dlen,
+                                   const unsigned char* key, unsigned int klen,
+                                   const unsigned char* iv, unsigned int ivlen,
+                                   int flags, unsigned int key_id, unsigned int key_version)
+{
+  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
+  int res1, res2;
+  unsigned int d1, d2;
+  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
+    return res1;
+  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
+  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
+  *dlen= d1 + d2;
+  return res1 ? res1 : res2;
+}
+struct st_encryption_scheme_key {
+  unsigned int version;
+  unsigned char key[16];
+};
+struct st_encryption_scheme {
+  unsigned char iv[16];
+  struct st_encryption_scheme_key key[3];
+  unsigned int keyserver_requests;
+  unsigned int key_id;
+  unsigned int type;
+  void (*locker)(struct st_encryption_scheme *self, int release);
+};
+extern struct encryption_scheme_service_st {
+  int (*encryption_scheme_encrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+  int (*encryption_scheme_decrypt_func)
+                               (const unsigned char* src, unsigned int slen,
+                                unsigned char* dst, unsigned int* dlen,
+                                struct st_encryption_scheme *scheme,
+                                unsigned int key_version, unsigned int i32_1,
+                                unsigned int i32_2, unsigned long long i64);
+} *encryption_scheme_service;
+int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
+                              unsigned char* dst, unsigned int* dlen,
+                              struct st_encryption_scheme *scheme,
+                              unsigned int key_version, unsigned int i32_1,
+                              unsigned int i32_2, unsigned long long i64);
+enum thd_kill_levels {
+  THD_IS_NOT_KILLED=0,
+  THD_ABORT_SOFTLY=50,
+  THD_ABORT_ASAP=100,
+};
+extern struct kill_statement_service_st {
+  enum thd_kill_levels (*thd_kill_level_func)(const void*);
+} *thd_kill_statement_service;
+enum thd_kill_levels thd_kill_level(const void*);
+typedef struct logger_handle_st LOGGER_HANDLE;
+extern struct logger_service_st {
+  void (*logger_init_mutexes)();
+  LOGGER_HANDLE* (*open)(const char *path,
+                         unsigned long long size_limit,
+                         unsigned int rotations);
+  int (*close)(LOGGER_HANDLE *log);
+  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
+  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int (*rotate)(LOGGER_HANDLE *log);
+} *logger_service;
+  void logger_init_mutexes();
+  LOGGER_HANDLE *logger_open(const char *path,
+                             unsigned long long size_limit,
+                             unsigned int rotations);
+  int logger_close(LOGGER_HANDLE *log);
+  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
+  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
+  int logger_rotate(LOGGER_HANDLE *log);
+extern struct my_md5_service_st {
+  void (*my_md5_type)(unsigned char*, const char*, size_t);
+  void (*my_md5_multi_type)(unsigned char*, ...);
+  size_t (*my_md5_context_size_type)();
+  void (*my_md5_init_type)(void *);
+  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
+  void (*my_md5_result_type)(void *, unsigned char *);
+} *my_md5_service;
+void my_md5(unsigned char*, const char*, size_t);
+void my_md5_multi(unsigned char*, ...);
+size_t my_md5_context_size();
+void my_md5_init(void *context);
+void my_md5_input(void *context, const unsigned char *buf, size_t len);
+void my_md5_result(void *context, unsigned char *digest);
 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);
-struct st_mysql_lex_string
-{
-  char *str;
-  size_t length;
-};
-typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
-extern struct thd_alloc_service_st {
-  void *(*thd_alloc_func)(void*, unsigned int);
-  void *(*thd_calloc_func)(void*, unsigned int);
-  char *(*thd_strdup_func)(void*, const char *);
-  char *(*thd_strmake_func)(void*, const char *, unsigned int);
-  void *(*thd_memdup_func)(void*, const void*, unsigned int);
-  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
-                                        const char *, unsigned int, int);
-} *thd_alloc_service;
-void *thd_alloc(void* thd, unsigned int size);
-void *thd_calloc(void* thd, unsigned int size);
-char *thd_strdup(void* thd, const char *str);
-char *thd_strmake(void* thd, const char *str, unsigned int size);
-void *thd_memdup(void* thd, const void* str, unsigned int size);
-MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
-                                      const char *str, unsigned int size,
-                                      int allocate_lex_string);
-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_NET= 11,
-  THD_WAIT_LAST= 12
-} 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);
 extern struct progress_report_service_st {
   void (*thd_progress_init_func)(void* thd, unsigned int max_stage);
   void (*thd_progress_report_func)(void* thd,
@@ -69,35 +163,20 @@ void thd_progress_next_stage(void* thd);
 void thd_progress_end(void* thd);
 const char *set_thd_proc_info(void*, const char * info, const char *func,
                               const char *file, unsigned int line);
-extern void (*debug_sync_C_callback_ptr)(void*, const char *, size_t);
-enum thd_kill_levels {
-  THD_IS_NOT_KILLED=0,
-  THD_ABORT_SOFTLY=50,
-  THD_ABORT_ASAP=100,
-};
-extern struct kill_statement_service_st {
-  enum thd_kill_levels (*thd_kill_level_func)(const void*);
-} *thd_kill_statement_service;
-enum thd_kill_levels thd_kill_level(const void*);
-typedef long my_time_t;
-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;
-extern struct thd_timezone_service_st {
-  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
-} *thd_timezone_service;
-my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
-void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+extern struct my_sha1_service_st {
+  void (*my_sha1_type)(unsigned char*, const char*, size_t);
+  void (*my_sha1_multi_type)(unsigned char*, ...);
+  size_t (*my_sha1_context_size_type)();
+  void (*my_sha1_init_type)(void *);
+  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
+  void (*my_sha1_result_type)(void *, unsigned char *);
+} *my_sha1_service;
+void my_sha1(unsigned char*, const char*, size_t);
+void my_sha1_multi(unsigned char*, ...);
+size_t my_sha1_context_size();
+void my_sha1_init(void *context);
+void my_sha1_input(void *context, const unsigned char *buf, size_t len);
+void my_sha1_result(void *context, unsigned char *digest);
 extern struct my_sha2_service_st {
   void (*my_sha224_type)(unsigned char*, const char*, size_t);
   void (*my_sha224_multi_type)(unsigned char*, ...);
@@ -148,83 +227,35 @@ size_t my_sha512_context_size();
 void my_sha512_init(void *context);
 void my_sha512_input(void *context, const unsigned char *buf, size_t len);
 void my_sha512_result(void *context, unsigned char *digest);
-extern struct my_sha1_service_st {
-  void (*my_sha1_type)(unsigned char*, const char*, size_t);
-  void (*my_sha1_multi_type)(unsigned char*, ...);
-  size_t (*my_sha1_context_size_type)();
-  void (*my_sha1_init_type)(void *);
-  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
-  void (*my_sha1_result_type)(void *, unsigned char *);
-} *my_sha1_service;
-void my_sha1(unsigned char*, const char*, size_t);
-void my_sha1_multi(unsigned char*, ...);
-size_t my_sha1_context_size();
-void my_sha1_init(void *context);
-void my_sha1_input(void *context, const unsigned char *buf, size_t len);
-void my_sha1_result(void *context, unsigned char *digest);
-extern struct my_md5_service_st {
-  void (*my_md5_type)(unsigned char*, const char*, size_t);
-  void (*my_md5_multi_type)(unsigned char*, ...);
-  size_t (*my_md5_context_size_type)();
-  void (*my_md5_init_type)(void *);
-  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
-  void (*my_md5_result_type)(void *, unsigned char *);
-} *my_md5_service;
-void my_md5(unsigned char*, const char*, size_t);
-void my_md5_multi(unsigned char*, ...);
-size_t my_md5_context_size();
-void my_md5_init(void *context);
-void my_md5_input(void *context, const unsigned char *buf, size_t len);
-void my_md5_result(void *context, unsigned char *digest);
-extern struct base64_service_st {
-  int (*base64_needed_encoded_length_ptr)(int length_of_data);
-  int (*base64_encode_max_arg_length_ptr)(void);
-  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
-  int (*base64_decode_max_arg_length_ptr)();
-  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
-  int (*base64_decode_ptr)(const char *src, size_t src_len,
-                           void *dst, const char **end_ptr, int flags);
-} *base64_service;
-int base64_needed_encoded_length(int length_of_data);
-int base64_encode_max_arg_length(void);
-int base64_needed_decoded_length(int length_of_encoded_data);
-int base64_decode_max_arg_length();
-int base64_encode(const void *src, size_t src_len, char *dst);
-int base64_decode(const char *src, size_t src_len,
-                  void *dst, const char **end_ptr, int flags);
-typedef struct logger_handle_st LOGGER_HANDLE;
-extern struct logger_service_st {
-  void (*logger_init_mutexes)();
-  LOGGER_HANDLE* (*open)(const char *path,
-                         unsigned long long size_limit,
-                         unsigned int rotations);
-  int (*close)(LOGGER_HANDLE *log);
-  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
-  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int (*rotate)(LOGGER_HANDLE *log);
-} *logger_service;
-  void logger_init_mutexes();
-  LOGGER_HANDLE *logger_open(const char *path,
-                             unsigned long long size_limit,
-                             unsigned int rotations);
-  int logger_close(LOGGER_HANDLE *log);
-  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
-  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
-  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
-  int logger_rotate(LOGGER_HANDLE *log);
+struct st_mysql_lex_string
+{
+  char *str;
+  size_t length;
+};
+typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
+extern struct thd_alloc_service_st {
+  void *(*thd_alloc_func)(void*, unsigned int);
+  void *(*thd_calloc_func)(void*, unsigned int);
+  char *(*thd_strdup_func)(void*, const char *);
+  char *(*thd_strmake_func)(void*, const char *, unsigned int);
+  void *(*thd_memdup_func)(void*, const void*, unsigned int);
+  MYSQL_LEX_STRING *(*thd_make_lex_string_func)(void*, MYSQL_LEX_STRING *,
+                                        const char *, unsigned int, int);
+} *thd_alloc_service;
+void *thd_alloc(void* thd, unsigned int size);
+void *thd_calloc(void* thd, unsigned int size);
+char *thd_strdup(void* thd, const char *str);
+char *thd_strmake(void* thd, const char *str, unsigned int size);
+void *thd_memdup(void* thd, const void* str, unsigned int size);
+MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str,
+                                      const char *str, unsigned int size,
+                                      int allocate_lex_string);
 extern struct thd_autoinc_service_st {
   void (*thd_get_autoinc_func)(const void* thd,
                                unsigned long* off, unsigned long* inc);
 } *thd_autoinc_service;
 void thd_get_autoinc(const void* thd,
                      unsigned long* off, unsigned long* inc);
-extern struct thd_rnd_service_st {
-  double (*thd_rnd_ptr)(void* thd);
-  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
-} *thd_rnd_service;
-double thd_rnd(void* thd);
-void thd_create_random_password(void* thd, char *to, size_t length);
 extern struct thd_error_context_service_st {
   const char *(*thd_get_error_message_func)(const void* thd);
   unsigned int (*thd_get_error_number_func)(const void* thd);
@@ -242,6 +273,12 @@ void thd_inc_error_row(void* thd);
 char *thd_get_error_context_description(void* thd,
                                         char *buffer, unsigned int length,
                                         unsigned int max_query_length);
+extern struct thd_rnd_service_st {
+  double (*thd_rnd_ptr)(void* thd);
+  void (*thd_c_r_p_ptr)(void* thd, char *to, size_t length);
+} *thd_rnd_service;
+double thd_rnd(void* thd);
+void thd_create_random_password(void* thd, char *to, size_t length);
 typedef int MYSQL_THD_KEY_T;
 extern struct thd_specifics_service_st {
   int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
@@ -253,82 +290,45 @@ int thd_key_create(MYSQL_THD_KEY_T *key);
 void thd_key_delete(MYSQL_THD_KEY_T *key);
 void* thd_getspecific(void* thd, MYSQL_THD_KEY_T key);
 int thd_setspecific(void* thd, MYSQL_THD_KEY_T key, void *value);
-struct encryption_service_st {
-  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
-  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
-                                          unsigned char* buffer, unsigned int* length);
-  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
-  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
-                                  const unsigned char* iv, unsigned int ivlen,
-                                  int flags, unsigned int key_id,
-                                  unsigned int key_version);
-  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
-                                    unsigned char* dst, unsigned int* dlen);
-  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
-  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
-};
-extern struct encryption_service_st encryption_handler;
-static inline unsigned int encryption_key_id_exists(unsigned int id)
-{
-  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
-}
-static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
-{
-  unsigned int unused;
-  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
-}
-static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
-                                   unsigned char* dst, unsigned int* dlen,
-                                   const unsigned char* key, unsigned int klen,
-                                   const unsigned char* iv, unsigned int ivlen,
-                                   int flags, unsigned int key_id, unsigned int key_version)
+typedef long my_time_t;
+enum enum_mysql_timestamp_type
 {
-  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
-  int res1, res2;
-  unsigned int d1, d2;
-  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
-    return res1;
-  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
-  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
-  *dlen= d1 + d2;
-  return res1 ? res1 : res2;
-}
-struct st_encryption_scheme_key {
-  unsigned int version;
-  unsigned char key[16];
-};
-struct st_encryption_scheme {
-  unsigned char iv[16];
-  struct st_encryption_scheme_key key[3];
-  unsigned int keyserver_requests;
-  unsigned int key_id;
-  unsigned int type;
-  void (*locker)(struct st_encryption_scheme *self, int release);
+  MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
+  MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
 };
-extern struct encryption_scheme_service_st {
-  int (*encryption_scheme_encrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-  int (*encryption_scheme_decrypt_func)
-                               (const unsigned char* src, unsigned int slen,
-                                unsigned char* dst, unsigned int* dlen,
-                                struct st_encryption_scheme *scheme,
-                                unsigned int key_version, unsigned int i32_1,
-                                unsigned int i32_2, unsigned long long i64);
-} *encryption_scheme_service;
-int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
-int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
-                              unsigned char* dst, unsigned int* dlen,
-                              struct st_encryption_scheme *scheme,
-                              unsigned int key_version, unsigned int i32_1,
-                              unsigned int i32_2, unsigned long long i64);
+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;
+extern struct thd_timezone_service_st {
+  my_time_t (*thd_TIME_to_gmt_sec)(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+  void (*thd_gmt_sec_to_TIME)(void* thd, MYSQL_TIME *ltime, my_time_t t);
+} *thd_timezone_service;
+my_time_t thd_TIME_to_gmt_sec(void* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
+void thd_gmt_sec_to_TIME(void* thd, MYSQL_TIME *ltime, my_time_t t);
+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_NET= 11,
+  THD_WAIT_LAST= 12
+} 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);
 struct st_mysql_xid {
   long formatID;
   long gtrid_length;

include/mysql/services.h

@@ -19,24 +19,24 @@
 extern "C" {
 #endif
 
-#include <mysql/service_my_snprintf.h>
-#include <mysql/service_thd_alloc.h>
-#include <mysql/service_thd_wait.h>
-#include <mysql/service_progress_report.h>
+#include <mysql/service_base64.h>
 #include <mysql/service_debug_sync.h>
+#include <mysql/service_encryption.h>
+#include <mysql/service_encryption_scheme.h>
 #include <mysql/service_kill_statement.h>
-#include <mysql/service_thd_timezone.h>
-#include <mysql/service_sha2.h>
-#include <mysql/service_sha1.h>
-#include <mysql/service_md5.h>
-#include <mysql/service_base64.h>
 #include <mysql/service_logger.h>
+#include <mysql/service_md5.h>
+#include <mysql/service_my_snprintf.h>
+#include <mysql/service_progress_report.h>
+#include <mysql/service_sha1.h>
+#include <mysql/service_sha2.h>
+#include <mysql/service_thd_alloc.h>
 #include <mysql/service_thd_autoinc.h>
-#include <mysql/service_thd_rnd.h>
 #include <mysql/service_thd_error_context.h>
+#include <mysql/service_thd_rnd.h>
 #include <mysql/service_thd_specifics.h>
-#include <mysql/service_encryption.h>
-#include <mysql/service_encryption_scheme.h>
+#include <mysql/service_thd_timezone.h>
+#include <mysql/service_thd_wait.h>
 /*#include <mysql/service_wsrep.h>*/
 
 #ifdef __cplusplus

include/service_versions.h

@@ -23,21 +23,20 @@
 #define VERSION_debug_sync              0x1000
 #define VERSION_kill_statement          0x1000
 
+#define VERSION_base64                  0x0100
+#define VERSION_encryption              0x0300
+#define VERSION_encryption_scheme       0x0100
+#define VERSION_logger                  0x0100
+#define VERSION_my_md5                  0x0100
+#define VERSION_my_sha1                 0x0101
+#define VERSION_my_sha2                 0x0100
 #define VERSION_my_snprintf             0x0100
-#define VERSION_thd_alloc               0x0100
-#define VERSION_thd_wait                0x0100
 #define VERSION_progress_report         0x0100
-#define VERSION_thd_timezone            0x0100
-#define VERSION_my_sha2                 0x0100
-#define VERSION_my_sha1                 0x0101
-#define VERSION_my_md5                  0x0100
-#define VERSION_wsrep                   0x0201
-#define VERSION_logger                  0x0100
-#define VERSION_base64                  0x0100
-#define VERSION_thd_rnd                 0x0100
+#define VERSION_thd_alloc               0x0100
 #define VERSION_thd_autoinc             0x0100
 #define VERSION_thd_error_context       0x0100
+#define VERSION_thd_rnd                 0x0100
 #define VERSION_thd_specifics           0x0100
-#define VERSION_encryption              0x0300
-#define VERSION_encryption_scheme       0x0100
-
+#define VERSION_thd_timezone            0x0100
+#define VERSION_thd_wait                0x0100
+#define VERSION_wsrep                   0x0201

libservices/CMakeLists.txt

@@ -16,25 +16,26 @@
 INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include)
 
 SET(MYSQLSERVICES_SOURCES
+  base64_service.c
+  debug_sync_service.c
+  encryption_scheme_service.c
+  encryption_service.c
+  kill_statement_service.c
+  logger_service.c
+  my_md5_service.c
+  my_sha1_service.c
+  my_sha2_service.c
   my_snprintf_service.c
+  progress_report_service.c
   thd_alloc_service.c
-  thd_wait_service.c
-  thd_timezone_service.c
   thd_autoinc_service.c
   thd_error_context_service.c
   thd_rnd_service.c
   thd_specifics_service.c
-  progress_report_service.c
-  debug_sync_service.c
-  my_sha2_service.c
-  my_sha1_service.c
-  my_md5_service.c
-  base64_service.c
+  thd_timezone_service.c
+  thd_wait_service.c
   wsrep_service.c
-  encryption_service.c
-  encryption_scheme_service.c
-  kill_statement_service.c
-  logger_service.c)
+)
 
 ADD_CONVENIENCE_LIBRARY(mysqlservices ${MYSQLSERVICES_SOURCES})
 INSTALL(TARGETS mysqlservices DESTINATION ${INSTALL_LIBDIR} COMPONENT Development)

sql/sql_plugin.cc

@@ -1550,8 +1550,8 @@ int plugin_init(int *argc, char **argv, int flags)
   }
 
   /* prepare debug_sync service */
-  DBUG_ASSERT(strcmp(list_of_services[4].name, "debug_sync_service") == 0);
-  list_of_services[4].service= *(void**)&debug_sync_C_callback_ptr;
+  DBUG_ASSERT(strcmp(list_of_services[1].name, "debug_sync_service") == 0);
+  list_of_services[1].service= *(void**)&debug_sync_C_callback_ptr;
 
   /* prepare encryption_keys service */
   finalize_encryption_plugin(0);

sql/sql_plugin_services.ic

@@ -198,24 +198,24 @@ static struct encryption_scheme_service_st encryption_scheme_handler=
 
 static struct st_service_ref list_of_services[]=
 {
+  { "base64_service",              VERSION_base64,              &base64_handler },
+  { "debug_sync_service",          VERSION_debug_sync,          0 }, // updated in plugin_init()
+  { "encryption_scheme_service",   VERSION_encryption_scheme,   &encryption_scheme_handler },
+  { "encryption_service",          VERSION_encryption,          &encryption_handler },
+  { "logger_service",              VERSION_logger,              &logger_service_handler },
+  { "my_md5_service",              VERSION_my_md5,              &my_md5_handler},
+  { "my_sha1_service",             VERSION_my_sha1,             &my_sha1_handler},
+  { "my_sha2_service",             VERSION_my_sha2,             &my_sha2_handler},
   { "my_snprintf_service",         VERSION_my_snprintf,         &my_snprintf_handler },
-  { "thd_alloc_service",           VERSION_thd_alloc,           &thd_alloc_handler },
-  { "thd_wait_service",            VERSION_thd_wait,            &thd_wait_handler },
   { "progress_report_service",     VERSION_progress_report,     &progress_report_handler },
-  { "debug_sync_service",          VERSION_debug_sync,          0 }, // updated in plugin_init()
+  { "thd_alloc_service",           VERSION_thd_alloc,           &thd_alloc_handler },
+  { "thd_autoinc_service",         VERSION_thd_autoinc,         &thd_autoinc_handler },
+  { "thd_error_context_service",   VERSION_thd_error_context,   &thd_error_conext_handler },
   { "thd_kill_statement_service",  VERSION_kill_statement,      &thd_kill_statement_handler },
-  { "thd_timezone_service",        VERSION_thd_timezone,        &thd_timezone_handler },
-  { "my_sha2_service",             VERSION_my_sha2,             &my_sha2_handler},
-  { "my_sha1_service",             VERSION_my_sha1,             &my_sha1_handler},
-  { "my_md5_service",              VERSION_my_md5,              &my_md5_handler},
-  { "logger_service",              VERSION_logger,              &logger_service_handler },
-  { "base64_service",              VERSION_base64,              &base64_handler },
   { "thd_rnd_service",             VERSION_thd_rnd,             &thd_rnd_handler },
-  { "thd_autoinc_service",         VERSION_thd_autoinc,         &thd_autoinc_handler },
-  { "wsrep_service",               VERSION_wsrep,               &wsrep_handler },
-  { "encryption_service",          VERSION_encryption,          &encryption_handler },
-  { "encryption_scheme_service",   VERSION_encryption_scheme,   &encryption_scheme_handler },
   { "thd_specifics_service",       VERSION_thd_specifics,       &thd_specifics_handler },
-  { "thd_error_context_service",   VERSION_thd_error_context,   &thd_error_conext_handler },
+  { "thd_timezone_service",        VERSION_thd_timezone,        &thd_timezone_handler },
+  { "thd_wait_service",            VERSION_thd_wait,            &thd_wait_handler },
+  { "wsrep_service",               VERSION_wsrep,               &wsrep_handler },
 };