1class THD;
2class Item;
3typedef char my_bool;
4typedef void * MYSQL_PLUGIN;
5extern "C" {
6extern "C" {
7extern struct base64_service_st {
8  int (*base64_needed_encoded_length_ptr)(int length_of_data);
9  int (*base64_encode_max_arg_length_ptr)(void);
10  int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
11  int (*base64_decode_max_arg_length_ptr)();
12  int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
13  int (*base64_decode_ptr)(const char *src, size_t src_len,
14                           void *dst, const char **end_ptr, int flags);
15} *base64_service;
16int my_base64_needed_encoded_length(int length_of_data);
17int my_base64_encode_max_arg_length(void);
18int my_base64_needed_decoded_length(int length_of_encoded_data);
19int my_base64_decode_max_arg_length();
20int my_base64_encode(const void *src, size_t src_len, char *dst);
21int my_base64_decode(const char *src, size_t src_len,
22                  void *dst, const char **end_ptr, int flags);
23}
24extern "C" {
25extern void (*debug_sync_C_callback_ptr)(THD*, const char *, size_t);
26}
27extern "C" {
28struct encryption_service_st {
29  unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
30  unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
31                                          unsigned char* buffer, unsigned int* length);
32  unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
33  int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
34                                  const unsigned char* iv, unsigned int ivlen,
35                                  int flags, unsigned int key_id,
36                                  unsigned int key_version);
37  int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
38                                    unsigned char* dst, unsigned int* dlen);
39  int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
40  unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
41};
42extern struct encryption_service_st encryption_handler;
43static inline unsigned int encryption_key_id_exists(unsigned int id)
44{
45  return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
46}
47static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
48{
49  unsigned int unused;
50  return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
51}
52static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
53                                   unsigned char* dst, unsigned int* dlen,
54                                   const unsigned char* key, unsigned int klen,
55                                   const unsigned char* iv, unsigned int ivlen,
56                                   int flags, unsigned int key_id, unsigned int key_version)
57{
58  void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
59  int res1, res2;
60  unsigned int d1, d2;
61  if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
62    return res1;
63  res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
64  res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
65  *dlen= d1 + d2;
66  return res1 ? res1 : res2;
67}
68}
69extern "C" {
70struct st_encryption_scheme_key {
71  unsigned int version;
72  unsigned char key[16];
73};
74struct st_encryption_scheme {
75  unsigned char iv[16];
76  struct st_encryption_scheme_key key[3];
77  unsigned int keyserver_requests;
78  unsigned int key_id;
79  unsigned int type;
80  void (*locker)(struct st_encryption_scheme *self, int release);
81};
82extern struct encryption_scheme_service_st {
83  int (*encryption_scheme_encrypt_func)
84                               (const unsigned char* src, unsigned int slen,
85                                unsigned char* dst, unsigned int* dlen,
86                                struct st_encryption_scheme *scheme,
87                                unsigned int key_version, unsigned int i32_1,
88                                unsigned int i32_2, unsigned long long i64);
89  int (*encryption_scheme_decrypt_func)
90                               (const unsigned char* src, unsigned int slen,
91                                unsigned char* dst, unsigned int* dlen,
92                                struct st_encryption_scheme *scheme,
93                                unsigned int key_version, unsigned int i32_1,
94                                unsigned int i32_2, unsigned long long i64);
95} *encryption_scheme_service;
96int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
97                              unsigned char* dst, unsigned int* dlen,
98                              struct st_encryption_scheme *scheme,
99                              unsigned int key_version, unsigned int i32_1,
100                              unsigned int i32_2, unsigned long long i64);
101int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
102                              unsigned char* dst, unsigned int* dlen,
103                              struct st_encryption_scheme *scheme,
104                              unsigned int key_version, unsigned int i32_1,
105                              unsigned int i32_2, unsigned long long i64);
106}
107extern "C" {
108enum thd_kill_levels {
109  THD_IS_NOT_KILLED=0,
110  THD_ABORT_SOFTLY=50,
111  THD_ABORT_ASAP=100,
112};
113extern struct kill_statement_service_st {
114  enum thd_kill_levels (*thd_kill_level_func)(const THD*);
115} *thd_kill_statement_service;
116enum thd_kill_levels thd_kill_level(const THD*);
117}
118extern "C" {
119typedef struct logger_handle_st LOGGER_HANDLE;
120extern struct logger_service_st {
121  void (*logger_init_mutexes)();
122  LOGGER_HANDLE* (*open)(const char *path,
123                         unsigned long long size_limit,
124                         unsigned int rotations);
125  int (*close)(LOGGER_HANDLE *log);
126  int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
127  int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
128  int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
129  int (*rotate)(LOGGER_HANDLE *log);
130} *logger_service;
131  void logger_init_mutexes();
132  LOGGER_HANDLE *logger_open(const char *path,
133                             unsigned long long size_limit,
134                             unsigned int rotations);
135  int logger_close(LOGGER_HANDLE *log);
136  int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
137  int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
138  int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
139  int logger_rotate(LOGGER_HANDLE *log);
140}
141extern "C" {
142extern struct my_md5_service_st {
143  void (*my_md5_type)(unsigned char*, const char*, size_t);
144  void (*my_md5_multi_type)(unsigned char*, ...);
145  size_t (*my_md5_context_size_type)();
146  void (*my_md5_init_type)(void *);
147  void (*my_md5_input_type)(void *, const unsigned char *, size_t);
148  void (*my_md5_result_type)(void *, unsigned char *);
149} *my_md5_service;
150void my_md5(unsigned char*, const char*, size_t);
151void my_md5_multi(unsigned char*, ...);
152size_t my_md5_context_size();
153void my_md5_init(void *context);
154void my_md5_input(void *context, const unsigned char *buf, size_t len);
155void my_md5_result(void *context, unsigned char *digest);
156}
157extern "C" {
158enum my_aes_mode {
159    MY_AES_ECB, MY_AES_CBC
160};
161extern struct my_crypt_service_st {
162  int (*my_aes_crypt_init)(void *ctx, enum my_aes_mode mode, int flags,
163                      const unsigned char* key, unsigned int klen,
164                      const unsigned char* iv, unsigned int ivlen);
165  int (*my_aes_crypt_update)(void *ctx, const unsigned char *src, unsigned int slen,
166                        unsigned char *dst, unsigned int *dlen);
167  int (*my_aes_crypt_finish)(void *ctx, unsigned char *dst, unsigned int *dlen);
168  int (*my_aes_crypt)(enum my_aes_mode mode, int flags,
169                 const unsigned char *src, unsigned int slen, unsigned char *dst, unsigned int *dlen,
170                 const unsigned char *key, unsigned int klen, const unsigned char *iv, unsigned int ivlen);
171  unsigned int (*my_aes_get_size)(enum my_aes_mode mode, unsigned int source_length);
172  unsigned int (*my_aes_ctx_size)(enum my_aes_mode mode);
173  int (*my_random_bytes)(unsigned char* buf, int num);
174} *my_crypt_service;
175int my_aes_crypt_init(void *ctx, enum my_aes_mode mode, int flags,
176                      const unsigned char* key, unsigned int klen,
177                      const unsigned char* iv, unsigned int ivlen);
178int my_aes_crypt_update(void *ctx, const unsigned char *src, unsigned int slen,
179                        unsigned char *dst, unsigned int *dlen);
180int my_aes_crypt_finish(void *ctx, unsigned char *dst, unsigned int *dlen);
181int my_aes_crypt(enum my_aes_mode mode, int flags,
182                 const unsigned char *src, unsigned int slen, unsigned char *dst, unsigned int *dlen,
183                 const unsigned char *key, unsigned int klen, const unsigned char *iv, unsigned int ivlen);
184int my_random_bytes(unsigned char* buf, int num);
185unsigned int my_aes_get_size(enum my_aes_mode mode, unsigned int source_length);
186unsigned int my_aes_ctx_size(enum my_aes_mode mode);
187}
188extern "C" {
189extern struct my_print_error_service_st {
190  void (*my_error_func)(unsigned int nr, unsigned long MyFlags, ...);
191  void (*my_printf_error_func)(unsigned int nr, const char *fmt, unsigned long MyFlags,...);
192  void (*my_printv_error_func)(unsigned int error, const char *format, unsigned long MyFlags, va_list ap);
193} *my_print_error_service;
194extern void my_error(unsigned int nr, unsigned long MyFlags, ...);
195extern void my_printf_error(unsigned int my_err, const char *format, unsigned long MyFlags, ...);
196extern void my_printv_error(unsigned int error, const char *format, unsigned long MyFlags,va_list ap);
197}
198extern "C" {
199extern struct my_snprintf_service_st {
200  size_t (*my_snprintf_type)(char*, size_t, const char*, ...);
201  size_t (*my_vsnprintf_type)(char *, size_t, const char*, va_list);
202} *my_snprintf_service;
203size_t my_snprintf(char* to, size_t n, const char* fmt, ...);
204size_t my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap);
205}
206extern "C" {
207extern struct progress_report_service_st {
208  void (*thd_progress_init_func)(THD* thd, unsigned int max_stage);
209  void (*thd_progress_report_func)(THD* thd,
210                                   unsigned long long progress,
211                                   unsigned long long max_progress);
212  void (*thd_progress_next_stage_func)(THD* thd);
213  void (*thd_progress_end_func)(THD* thd);
214  const char *(*set_thd_proc_info_func)(THD*, const char *info,
215                                        const char *func,
216                                        const char *file,
217                                        unsigned int line);
218} *progress_report_service;
219void thd_progress_init(THD* thd, unsigned int max_stage);
220void thd_progress_report(THD* thd,
221                         unsigned long long progress,
222                         unsigned long long max_progress);
223void thd_progress_next_stage(THD* thd);
224void thd_progress_end(THD* thd);
225const char *set_thd_proc_info(THD*, const char * info, const char *func,
226                              const char *file, unsigned int line);
227}
228extern "C" {
229extern struct my_sha1_service_st {
230  void (*my_sha1_type)(unsigned char*, const char*, size_t);
231  void (*my_sha1_multi_type)(unsigned char*, ...);
232  size_t (*my_sha1_context_size_type)();
233  void (*my_sha1_init_type)(void *);
234  void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
235  void (*my_sha1_result_type)(void *, unsigned char *);
236} *my_sha1_service;
237void my_sha1(unsigned char*, const char*, size_t);
238void my_sha1_multi(unsigned char*, ...);
239size_t my_sha1_context_size();
240void my_sha1_init(void *context);
241void my_sha1_input(void *context, const unsigned char *buf, size_t len);
242void my_sha1_result(void *context, unsigned char *digest);
243}
244extern "C" {
245extern struct my_sha2_service_st {
246  void (*my_sha224_type)(unsigned char*, const char*, size_t);
247  void (*my_sha224_multi_type)(unsigned char*, ...);
248  size_t (*my_sha224_context_size_type)();
249  void (*my_sha224_init_type)(void *);
250  void (*my_sha224_input_type)(void *, const unsigned char *, size_t);
251  void (*my_sha224_result_type)(void *, unsigned char *);
252  void (*my_sha256_type)(unsigned char*, const char*, size_t);
253  void (*my_sha256_multi_type)(unsigned char*, ...);
254  size_t (*my_sha256_context_size_type)();
255  void (*my_sha256_init_type)(void *);
256  void (*my_sha256_input_type)(void *, const unsigned char *, size_t);
257  void (*my_sha256_result_type)(void *, unsigned char *);
258  void (*my_sha384_type)(unsigned char*, const char*, size_t);
259  void (*my_sha384_multi_type)(unsigned char*, ...);
260  size_t (*my_sha384_context_size_type)();
261  void (*my_sha384_init_type)(void *);
262  void (*my_sha384_input_type)(void *, const unsigned char *, size_t);
263  void (*my_sha384_result_type)(void *, unsigned char *);
264  void (*my_sha512_type)(unsigned char*, const char*, size_t);
265  void (*my_sha512_multi_type)(unsigned char*, ...);
266  size_t (*my_sha512_context_size_type)();
267  void (*my_sha512_init_type)(void *);
268  void (*my_sha512_input_type)(void *, const unsigned char *, size_t);
269  void (*my_sha512_result_type)(void *, unsigned char *);
270} *my_sha2_service;
271void my_sha224(unsigned char*, const char*, size_t);
272void my_sha224_multi(unsigned char*, ...);
273size_t my_sha224_context_size();
274void my_sha224_init(void *context);
275void my_sha224_input(void *context, const unsigned char *buf, size_t len);
276void my_sha224_result(void *context, unsigned char *digest);
277void my_sha256(unsigned char*, const char*, size_t);
278void my_sha256_multi(unsigned char*, ...);
279size_t my_sha256_context_size();
280void my_sha256_init(void *context);
281void my_sha256_input(void *context, const unsigned char *buf, size_t len);
282void my_sha256_result(void *context, unsigned char *digest);
283void my_sha384(unsigned char*, const char*, size_t);
284void my_sha384_multi(unsigned char*, ...);
285size_t my_sha384_context_size();
286void my_sha384_init(void *context);
287void my_sha384_input(void *context, const unsigned char *buf, size_t len);
288void my_sha384_result(void *context, unsigned char *digest);
289void my_sha512(unsigned char*, const char*, size_t);
290void my_sha512_multi(unsigned char*, ...);
291size_t my_sha512_context_size();
292void my_sha512_init(void *context);
293void my_sha512_input(void *context, const unsigned char *buf, size_t len);
294void my_sha512_result(void *context, unsigned char *digest);
295}
296extern "C" {
297struct st_mysql_lex_string
298{
299  char *str;
300  size_t length;
301};
302typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
303struct st_mysql_const_lex_string
304{
305  const char *str;
306  size_t length;
307};
308typedef struct st_mysql_const_lex_string MYSQL_CONST_LEX_STRING;
309extern struct thd_alloc_service_st {
310  void *(*thd_alloc_func)(THD*, size_t);
311  void *(*thd_calloc_func)(THD*, size_t);
312  char *(*thd_strdup_func)(THD*, const char *);
313  char *(*thd_strmake_func)(THD*, const char *, size_t);
314  void *(*thd_memdup_func)(THD*, const void*, size_t);
315  MYSQL_CONST_LEX_STRING *(*thd_make_lex_string_func)(THD*,
316                                        MYSQL_CONST_LEX_STRING *,
317                                        const char *, size_t, int);
318} *thd_alloc_service;
319void *thd_alloc(THD* thd, size_t size);
320void *thd_calloc(THD* thd, size_t size);
321char *thd_strdup(THD* thd, const char *str);
322char *thd_strmake(THD* thd, const char *str, size_t size);
323void *thd_memdup(THD* thd, const void* str, size_t size);
324MYSQL_CONST_LEX_STRING
325*thd_make_lex_string(THD* thd, MYSQL_CONST_LEX_STRING *lex_str,
326                     const char *str, size_t size,
327                     int allocate_lex_string);
328}
329extern "C" {
330extern struct thd_autoinc_service_st {
331  void (*thd_get_autoinc_func)(const THD* thd,
332                               unsigned long* off, unsigned long* inc);
333} *thd_autoinc_service;
334void thd_get_autoinc(const THD* thd,
335                     unsigned long* off, unsigned long* inc);
336}
337extern "C" {
338extern struct thd_error_context_service_st {
339  const char *(*thd_get_error_message_func)(const THD* thd);
340  unsigned int (*thd_get_error_number_func)(const THD* thd);
341  unsigned long (*thd_get_error_row_func)(const THD* thd);
342  void (*thd_inc_error_row_func)(THD* thd);
343  char *(*thd_get_error_context_description_func)(THD* thd,
344                                                  char *buffer,
345                                                  unsigned int length,
346                                                  unsigned int max_query_length);
347} *thd_error_context_service;
348const char *thd_get_error_message(const THD* thd);
349unsigned int thd_get_error_number(const THD* thd);
350unsigned long thd_get_error_row(const THD* thd);
351void thd_inc_error_row(THD* thd);
352char *thd_get_error_context_description(THD* thd,
353                                        char *buffer, unsigned int length,
354                                        unsigned int max_query_length);
355}
356extern "C" {
357extern struct thd_rnd_service_st {
358  double (*thd_rnd_ptr)(THD* thd);
359  void (*thd_c_r_p_ptr)(THD* thd, char *to, size_t length);
360} *thd_rnd_service;
361double thd_rnd(THD* thd);
362void thd_create_random_password(THD* thd, char *to, size_t length);
363}
364extern "C" {
365typedef int MYSQL_THD_KEY_T;
366extern struct thd_specifics_service_st {
367  int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
368  void (*thd_key_delete_func)(MYSQL_THD_KEY_T *key);
369  void *(*thd_getspecific_func)(THD* thd, MYSQL_THD_KEY_T key);
370  int (*thd_setspecific_func)(THD* thd, MYSQL_THD_KEY_T key, void *value);
371} *thd_specifics_service;
372int thd_key_create(MYSQL_THD_KEY_T *key);
373void thd_key_delete(MYSQL_THD_KEY_T *key);
374void* thd_getspecific(THD* thd, MYSQL_THD_KEY_T key);
375int thd_setspecific(THD* thd, MYSQL_THD_KEY_T key, void *value);
376}
377typedef long my_time_t;
378enum enum_mysql_timestamp_type
379{
380  MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
381  MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
382};
383typedef struct st_mysql_time
384{
385  unsigned int year, month, day, hour, minute, second;
386  unsigned long second_part;
387  my_bool neg;
388  enum enum_mysql_timestamp_type time_type;
389} MYSQL_TIME;
390extern "C" {
391extern struct thd_timezone_service_st {
392  my_time_t (*thd_TIME_to_gmt_sec)(THD* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
393  void (*thd_gmt_sec_to_TIME)(THD* thd, MYSQL_TIME *ltime, my_time_t t);
394} *thd_timezone_service;
395my_time_t thd_TIME_to_gmt_sec(THD* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
396void thd_gmt_sec_to_TIME(THD* thd, MYSQL_TIME *ltime, my_time_t t);
397}
398extern "C" {
399typedef enum _thd_wait_type_e {
400  THD_WAIT_SLEEP= 1,
401  THD_WAIT_DISKIO= 2,
402  THD_WAIT_ROW_LOCK= 3,
403  THD_WAIT_GLOBAL_LOCK= 4,
404  THD_WAIT_META_DATA_LOCK= 5,
405  THD_WAIT_TABLE_LOCK= 6,
406  THD_WAIT_USER_LOCK= 7,
407  THD_WAIT_BINLOG= 8,
408  THD_WAIT_GROUP_COMMIT= 9,
409  THD_WAIT_SYNC= 10,
410  THD_WAIT_NET= 11,
411  THD_WAIT_LAST= 12
412} thd_wait_type;
413extern struct thd_wait_service_st {
414  void (*thd_wait_begin_func)(THD*, int);
415  void (*thd_wait_end_func)(THD*);
416} *thd_wait_service;
417void thd_wait_begin(THD* thd, int wait_type);
418void thd_wait_end(THD* thd);
419}
420extern "C" {
421enum json_types
422{
423  JSV_BAD_JSON=-1,
424  JSV_NOTHING=0,
425  JSV_OBJECT=1,
426  JSV_ARRAY=2,
427  JSV_STRING=3,
428  JSV_NUMBER=4,
429  JSV_TRUE=5,
430  JSV_FALSE=6,
431  JSV_NULL=7
432};
433extern struct json_service_st {
434  enum json_types (*json_type)(const char *js, const char *js_end,
435                               const char **value, int *value_len);
436  enum json_types (*json_get_array_item)(const char *js, const char *js_end,
437                                         int n_item,
438                                         const char **value, int *value_len);
439  enum json_types (*json_get_object_key)(const char *js, const char *js_end,
440                                         const char *key,
441                                         const char **value, int *value_len);
442  enum json_types (*json_get_object_nkey)(const char *js,const char *js_end,
443                             int nkey,
444                             const char **keyname, const char **keyname_end,
445                             const char **value, int *value_len);
446  int (*json_escape_string)(const char *str,const char *str_end,
447                          char *json, char *json_end);
448  int (*json_unescape_json)(const char *json_str, const char *json_end,
449                          char *res, char *res_end);
450} *json_service;
451enum json_types json_type(const char *js, const char *js_end,
452                          const char **value, int *value_len);
453enum json_types json_get_array_item(const char *js, const char *js_end,
454                                    int n_item,
455                                    const char **value, int *value_len);
456enum json_types json_get_object_key(const char *js, const char *js_end,
457                                    const char *key,
458                                    const char **value, int *value_len);
459enum json_types json_get_object_nkey(const char *js,const char *js_end, int nkey,
460                       const char **keyname, const char **keyname_end,
461                       const char **value, int *value_len);
462int json_escape_string(const char *str,const char *str_end,
463                       char *json, char *json_end);
464int json_unescape_json(const char *json_str, const char *json_end,
465                       char *res, char *res_end);
466}
467}
468struct st_mysql_xid {
469  long formatID;
470  long gtrid_length;
471  long bqual_length;
472  char data[128];
473};
474typedef struct st_mysql_xid MYSQL_XID;
475enum enum_mysql_show_type
476{
477  SHOW_UNDEF, SHOW_BOOL, SHOW_UINT, SHOW_ULONG,
478  SHOW_ULONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
479  SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE,
480  SHOW_SINT, SHOW_SLONG, SHOW_SLONGLONG, SHOW_SIMPLE_FUNC,
481  SHOW_SIZE_T, SHOW_always_last
482};
483enum enum_var_type
484{
485  SHOW_OPT_DEFAULT= 0, SHOW_OPT_SESSION, SHOW_OPT_GLOBAL
486};
487struct st_mysql_show_var {
488  const char *name;
489  void *value;
490  enum enum_mysql_show_type type;
491};
492struct system_status_var;
493typedef int (*mysql_show_var_func)(THD*, struct st_mysql_show_var*, void *, struct system_status_var *status_var, enum enum_var_type);
494struct st_mysql_sys_var;
495struct st_mysql_value;
496typedef int (*mysql_var_check_func)(THD* thd,
497                                    struct st_mysql_sys_var *var,
498                                    void *save, struct st_mysql_value *value);
499typedef void (*mysql_var_update_func)(THD* thd,
500                                      struct st_mysql_sys_var *var,
501                                      void *var_ptr, const void *save);
502struct st_mysql_plugin
503{
504  int type;
505  void *info;
506  const char *name;
507  const char *author;
508  const char *descr;
509  int license;
510  int (*init)(void *);
511  int (*deinit)(void *);
512  unsigned int version;
513  struct st_mysql_show_var *status_vars;
514  struct st_mysql_sys_var **system_vars;
515  void * __reserved1;
516  unsigned long flags;
517};
518struct st_maria_plugin
519{
520  int type;
521  void *info;
522  const char *name;
523  const char *author;
524  const char *descr;
525  int license;
526  int (*init)(void *);
527  int (*deinit)(void *);
528  unsigned int version;
529  struct st_mysql_show_var *status_vars;
530  struct st_mysql_sys_var **system_vars;
531  const char *version_info;
532  unsigned int maturity;
533};
534extern "C" {
535enum enum_ftparser_mode
536{
537  MYSQL_FTPARSER_SIMPLE_MODE= 0,
538  MYSQL_FTPARSER_WITH_STOPWORDS= 1,
539  MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2
540};
541enum enum_ft_token_type
542{
543  FT_TOKEN_EOF= 0,
544  FT_TOKEN_WORD= 1,
545  FT_TOKEN_LEFT_PAREN= 2,
546  FT_TOKEN_RIGHT_PAREN= 3,
547  FT_TOKEN_STOPWORD= 4
548};
549typedef struct st_mysql_ftparser_boolean_info
550{
551  enum enum_ft_token_type type;
552  int yesno;
553  int weight_adjust;
554  char wasign;
555  char trunc;
556  char prev;
557  char *quot;
558} MYSQL_FTPARSER_BOOLEAN_INFO;
559typedef struct st_mysql_ftparser_param
560{
561  int (*mysql_parse)(struct st_mysql_ftparser_param *,
562                     const char *doc, int doc_len);
563  int (*mysql_add_word)(struct st_mysql_ftparser_param *,
564                        const char *word, int word_len,
565                        MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info);
566  void *ftparser_state;
567  void *mysql_ftparam;
568  const struct charset_info_st *cs;
569  const char *doc;
570  int length;
571  unsigned int flags;
572  enum enum_ftparser_mode mode;
573} MYSQL_FTPARSER_PARAM;
574struct st_mysql_ftparser
575{
576  int interface_version;
577  int (*parse)(MYSQL_FTPARSER_PARAM *param);
578  int (*init)(MYSQL_FTPARSER_PARAM *param);
579  int (*deinit)(MYSQL_FTPARSER_PARAM *param);
580};
581}
582struct st_mysql_daemon
583{
584  int interface_version;
585};
586struct st_mysql_information_schema
587{
588  int interface_version;
589};
590struct st_mysql_storage_engine
591{
592  int interface_version;
593};
594struct handlerton;
595 struct Mysql_replication {
596   int interface_version;
597 };
598struct st_mysql_value
599{
600  int (*value_type)(struct st_mysql_value *);
601  const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
602  int (*val_real)(struct st_mysql_value *, double *realbuf);
603  int (*val_int)(struct st_mysql_value *, long long *intbuf);
604  int (*is_unsigned)(struct st_mysql_value *);
605};
606extern "C" {
607int thd_in_lock_tables(const THD* thd);
608int thd_tablespace_op(const THD* thd);
609long long thd_test_options(const THD* thd, long long test_options);
610int thd_sql_command(const THD* thd);
611void thd_storage_lock_wait(THD* thd, long long value);
612int thd_tx_isolation(const THD* thd);
613int thd_tx_is_read_only(const THD* thd);
614int mysql_tmpfile(const char *prefix);
615unsigned long thd_get_thread_id(const THD* thd);
616void thd_get_xid(const THD* thd, MYSQL_XID *xid);
617void mysql_query_cache_invalidate4(THD* thd,
618                                   const char *key, unsigned int key_length,
619                                   int using_trx);
620void *thd_get_ha_data(const THD* thd, const struct handlerton *hton);
621void thd_set_ha_data(THD* thd, const struct handlerton *hton,
622                     const void *ha_data);
623void thd_wakeup_subsequent_commits(THD* thd, int wakeup_error);
624}
625extern "C" {
626struct st_mariadb_password_validation
627{
628  int interface_version;
629  int (*validate_password)(const MYSQL_CONST_LEX_STRING *username,
630                           const MYSQL_CONST_LEX_STRING *password);
631};
632}
633