← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_sys.h

  • Committer: Monty Taylor
  • Date: 2008-07-01 14:33:36 UTC
  • mto: (28.1.12 backport_patch)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: monty@inaugust.com-20080701143336-8uihm7dhpu92rt0q
Somehow missed moving password.c. Duh.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/my_sys.h
1
 
/* - mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 MySQL
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
 
1
/* Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
15
 
21
16
#ifndef _my_sys_h
22
17
#define _my_sys_h
 
18
C_MODE_START
 
19
 
 
20
#ifdef HAVE_AIOWAIT
 
21
#include <sys/asynch.h>                 /* Used by record-cache */
 
22
typedef struct my_aio_result {
 
23
  aio_result_t result;
 
24
  int          pending;
 
25
} my_aio_result;
 
26
#endif
23
27
 
24
28
#include <errno.h>
25
29
#define my_errno (errno)
26
30
 
27
 
#include <mysys/my_pthread.h>
 
31
#ifdef THREAD
 
32
#include <my_pthread.h>
 
33
#endif
28
34
 
29
 
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
 
35
#include <m_ctype.h>                    /* for CHARSET_INFO */
30
36
#include <stdarg.h>
31
 
#include <mysys/typelib.h>
32
 
#include <mysys/aio_result.h>
33
 
 
34
 
#include <mysys/my_alloc.h>
35
 
 
 
37
#include <typelib.h>
 
38
 
 
39
#define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
36
40
#define MY_INIT(name);          { my_progname= name; my_init(); }
37
41
 
38
42
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
48
52
#define MY_WAIT_IF_FULL 32      /* Wait and try again if disk full error */
49
53
#define MY_IGNORE_BADFD 32      /* my_sync: ignore 'bad descriptor' errors */
50
54
#define MY_SYNC_DIR     1024    /* my_create/delete/rename: sync directory */
 
55
#define MY_RAID         64      /* Support for RAID */
51
56
#define MY_FULL_IO     512      /* For my_read - loop intil I/O is complete */
52
57
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
53
58
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
67
72
 
68
73
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
69
74
#define MY_GIVE_INFO    2       /* Give time info about process*/
 
75
#define MY_DONT_FREE_DBUG 4     /* Do not call DBUG_END() in my_end() */
70
76
 
71
77
#define MY_REMOVE_NONE    0     /* Params for modify_defaults_file */
72
78
#define MY_REMOVE_OPTION  1
106
112
        /* Some constants */
107
113
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
108
114
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
 
115
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
109
116
#define DFLT_INIT_HITS  3
110
117
 
111
118
        /* root_alloc flags */
124
131
#define GETDATE_FIXEDLENGTH     16
125
132
 
126
133
        /* defines when allocating data */
 
134
#ifdef SAFEMALLOC
 
135
#else
127
136
#define my_checkmalloc()
128
137
#undef TERMINATE
129
138
#define TERMINATE(A,B) {}
130
 
 
131
 
#ifdef __cplusplus
132
 
extern "C" {
133
 
#endif
134
 
 
135
 
typedef int  (*qsort_cmp)(const void *,const void *);
136
 
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
137
 
 
 
139
#define QUICK_SAFEMALLOC
 
140
#define NORMAL_SAFEMALLOC
138
141
extern void *my_malloc(size_t Size,myf MyFlags);
139
142
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
140
143
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
143
146
extern char *my_strdup(const char *from,myf MyFlags);
144
147
extern char *my_strndup(const char *from, size_t length,
145
148
                                   myf MyFlags);
 
149
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
 
150
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
146
151
#define CALLER_INFO_PROTO   /* nothing */
147
152
#define CALLER_INFO         /* nothing */
148
153
#define ORIG_CALLER_INFO    /* nothing */
149
154
#define TRASH(A,B) /* nothing */
 
155
#endif
150
156
 
151
157
#ifdef HAVE_ALLOCA
152
158
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
153
159
#define alloca __builtin_alloca
154
160
#endif /* GNUC */
155
 
#define my_alloca(SZ) malloc((size_t) (SZ))
156
 
#define my_afree(PTR) free((PTR))
 
161
#define my_alloca(SZ) alloca((size_t) (SZ))
 
162
#define my_afree(PTR) {}
157
163
#else
158
 
#define my_alloca(SZ) malloc((SZ))
159
 
#define my_afree(PTR) free((PTR))
 
164
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
165
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
160
166
#endif /* HAVE_ALLOCA */
161
167
 
162
168
#ifndef errno                           /* did we already get it? */
169
175
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
170
176
extern char *home_dir;                  /* Home directory for user */
171
177
extern const char *my_progname;         /* program-name (printed in errors) */
172
 
extern void (*error_handler_hook)(uint32_t my_err, const char *str,myf MyFlags);
173
 
extern void (*fatal_error_handler_hook)(uint32_t my_err, const char *str,
 
178
extern char curr_dir[];         /* Current directory for user */
 
179
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
 
180
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
174
181
                                        myf MyFlags);
175
 
extern uint32_t my_file_limit;
176
 
extern uint32_t my_thread_stack_size;
 
182
extern uint my_file_limit;
 
183
extern ulong my_thread_stack_size;
177
184
 
178
185
/* charsets */
179
 
extern const CHARSET_INFO *default_charset_info;
 
186
extern CHARSET_INFO *default_charset_info;
180
187
extern CHARSET_INFO *all_charsets[256];
181
188
extern CHARSET_INFO compiled_charsets[];
182
189
 
183
190
/* statistics */
184
 
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
185
 
extern uint32_t    my_file_total_opened;
 
191
extern ulong    my_file_opened,my_stream_opened, my_tmp_file_created;
 
192
extern ulong    my_file_total_opened;
186
193
extern uint     mysys_usage_id;
187
 
extern bool     my_init_done;
 
194
extern my_bool  my_init_done;
188
195
 
189
196
                                        /* Point to current my_message() */
190
197
extern void (*my_sigtstp_cleanup)(void),
197
204
           my_recived_signals,  /* Signals we have got */
198
205
           my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
199
206
           my_dont_interrupt;   /* call remember_intr when set */
200
 
extern bool mysys_uses_curses, my_use_symdir;
201
 
extern uint32_t sf_malloc_cur_memory, sf_malloc_max_memory;
 
207
extern my_bool mysys_uses_curses, my_use_symdir;
 
208
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
202
209
 
203
 
extern uint32_t my_default_record_cache_size;
204
 
extern bool my_disable_async_io,
 
210
extern ulong    my_default_record_cache_size;
 
211
extern my_bool my_disable_locking, my_disable_async_io,
205
212
               my_disable_flush_key_blocks, my_disable_symlinks;
206
213
extern char     wild_many, wild_one, wild_prefix;
207
214
extern const char *charsets_dir;
210
217
extern const char *my_defaults_group_suffix;
211
218
extern const char *my_defaults_file;
212
219
 
213
 
extern bool timed_mutexes;
 
220
extern my_bool timed_mutexes;
214
221
 
215
222
typedef struct wild_file_pack   /* Struct to hold info when selecting files */
216
223
{
231
238
  SEQ_READ_APPEND               /* sequential read or append */,
232
239
  READ_FIFO, READ_NET,WRITE_NET};
233
240
 
 
241
enum flush_type
 
242
{
 
243
  FLUSH_KEEP,           /* flush block and keep it in the cache */
 
244
  FLUSH_RELEASE,        /* flush block and remove it from the cache */
 
245
  FLUSH_IGNORE_CHANGED, /* remove block from the cache */
 
246
  /*
 
247
    As my_disable_flush_pagecache_blocks is always 0, the following option
 
248
    is strictly equivalent to FLUSH_KEEP
 
249
  */
 
250
  FLUSH_FORCE_WRITE
 
251
};
 
252
 
234
253
typedef struct st_record_cache  /* Used when cacheing records */
235
254
{
236
255
  File file;
237
256
  int   rc_seek,error,inited;
238
257
  uint  rc_length,read_length,reclength;
239
258
  my_off_t rc_record_pos,end_of_file;
240
 
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
259
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
241
260
#ifdef HAVE_AIOWAIT
242
261
  int   use_async_io;
243
262
  my_aio_result aio_result;
255
274
{
256
275
  char *                name;
257
276
  enum file_type        type;
258
 
#if !defined(HAVE_PREAD)
 
277
#if defined(THREAD) && !defined(HAVE_PREAD)
259
278
  pthread_mutex_t       mutex;
260
279
#endif
261
280
};
264
283
 
265
284
typedef struct st_dynamic_array
266
285
{
267
 
  unsigned char *buffer;
268
 
  uint32_t elements,max_element;
269
 
  uint32_t alloc_increment;
270
 
  uint32_t size_of_element;
 
286
  uchar *buffer;
 
287
  uint elements,max_element;
 
288
  uint alloc_increment;
 
289
  uint size_of_element;
271
290
} DYNAMIC_ARRAY;
272
291
 
273
292
typedef struct st_my_tmpdir
274
293
{
275
294
  DYNAMIC_ARRAY full_list;
276
295
  char **list;
277
 
  uint32_t cur, max;
 
296
  uint cur, max;
 
297
#ifdef THREAD
278
298
  pthread_mutex_t mutex;
 
299
#endif
279
300
} MY_TMPDIR;
280
301
 
 
302
typedef struct st_dynamic_string
 
303
{
 
304
  char *str;
 
305
  size_t length,max_length,alloc_increment;
 
306
} DYNAMIC_STRING;
 
307
 
 
308
struct st_io_cache;
 
309
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
 
310
 
 
311
#ifdef THREAD
 
312
typedef struct st_io_cache_share
 
313
{
 
314
  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
 
315
  pthread_cond_t        cond;            /* To wait for signals. */
 
316
  pthread_cond_t        cond_writer;     /* For a synchronized writer. */
 
317
  /* Offset in file corresponding to the first byte of buffer. */
 
318
  my_off_t              pos_in_file;
 
319
  /* If a synchronized write cache is the source of the data. */
 
320
  struct st_io_cache    *source_cache;
 
321
  uchar                 *buffer;         /* The read buffer. */
 
322
  uchar                 *read_end;       /* Behind last valid byte of buffer. */
 
323
  int                   running_threads; /* threads not in lock. */
 
324
  int                   total_threads;   /* threads sharing the cache. */
 
325
  int                   error;           /* Last error. */
 
326
#ifdef NOT_YET_IMPLEMENTED
 
327
  /* whether the structure should be free'd */
 
328
  my_bool alloced;
 
329
#endif
 
330
} IO_CACHE_SHARE;
 
331
#endif
 
332
 
 
333
typedef struct st_io_cache              /* Used when cacheing files */
 
334
{
 
335
  /* Offset in file corresponding to the first byte of uchar* buffer. */
 
336
  my_off_t pos_in_file;
 
337
  /*
 
338
    The offset of end of file for READ_CACHE and WRITE_CACHE.
 
339
    For SEQ_READ_APPEND it the maximum of the actual end of file and
 
340
    the position represented by read_end.
 
341
  */
 
342
  my_off_t end_of_file;
 
343
  /* Points to current read position in the buffer */
 
344
  uchar *read_pos;
 
345
  /* the non-inclusive boundary in the buffer for the currently valid read */
 
346
  uchar  *read_end;
 
347
  uchar  *buffer;                               /* The read buffer */
 
348
  /* Used in ASYNC_IO */
 
349
  uchar  *request_pos;
 
350
 
 
351
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
 
352
  uchar  *write_buffer;
 
353
  /*
 
354
    Only used in SEQ_READ_APPEND, and points to the current read position
 
355
    in the write buffer. Note that reads in SEQ_READ_APPEND caches can
 
356
    happen from both read buffer (uchar* buffer) and write buffer
 
357
    (uchar* write_buffer).
 
358
  */
 
359
  uchar *append_read_pos;
 
360
  /* Points to current write position in the write buffer */
 
361
  uchar *write_pos;
 
362
  /* The non-inclusive boundary of the valid write area */
 
363
  uchar *write_end;
 
364
 
 
365
  /*
 
366
    Current_pos and current_end are convenience variables used by
 
367
    my_b_tell() and other routines that need to know the current offset
 
368
    current_pos points to &write_pos, and current_end to &write_end in a
 
369
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
 
370
  */
 
371
  uchar  **current_pos, **current_end;
 
372
#ifdef THREAD
 
373
  /*
 
374
    The lock is for append buffer used in SEQ_READ_APPEND cache
 
375
    need mutex copying from append buffer to read buffer.
 
376
  */
 
377
  pthread_mutex_t append_buffer_lock;
 
378
  /*
 
379
    The following is used when several threads are reading the
 
380
    same file in parallel. They are synchronized on disk
 
381
    accesses reading the cached part of the file asynchronously.
 
382
    It should be set to NULL to disable the feature.  Only
 
383
    READ_CACHE mode is supported.
 
384
  */
 
385
  IO_CACHE_SHARE *share;
 
386
#endif
 
387
  /*
 
388
    A caller will use my_b_read() macro to read from the cache
 
389
    if the data is already in cache, it will be simply copied with
 
390
    memcpy() and internal variables will be accordinging updated with
 
391
    no functions invoked. However, if the data is not fully in the cache,
 
392
    my_b_read() will call read_function to fetch the data. read_function
 
393
    must never be invoked directly.
 
394
  */
 
395
  int (*read_function)(struct st_io_cache *,uchar *,size_t);
 
396
  /*
 
397
    Same idea as in the case of read_function, except my_b_write() needs to
 
398
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
 
399
  */
 
400
  int (*write_function)(struct st_io_cache *,const uchar *,size_t);
 
401
  /*
 
402
    Specifies the type of the cache. Depending on the type of the cache
 
403
    certain operations might not be available and yield unpredicatable
 
404
    results. Details to be documented later
 
405
  */
 
406
  enum cache_type type;
 
407
  /*
 
408
    Callbacks when the actual read I/O happens. These were added and
 
409
    are currently used for binary logging of LOAD DATA INFILE - when a
 
410
    block is read from the file, we create a block create/append event, and
 
411
    when IO_CACHE is closed, we create an end event. These functions could,
 
412
    of course be used for other things
 
413
  */
 
414
  IO_CACHE_CALLBACK pre_read;
 
415
  IO_CACHE_CALLBACK post_read;
 
416
  IO_CACHE_CALLBACK pre_close;
 
417
  /*
 
418
    Counts the number of times, when we were forced to use disk. We use it to
 
419
    increase the binlog_cache_disk_use status variable.
 
420
  */
 
421
  ulong disk_writes;
 
422
  void* arg;                            /* for use by pre/post_read */
 
423
  char *file_name;                      /* if used with 'open_cached_file' */
 
424
  char *dir,*prefix;
 
425
  File file; /* file descriptor */
 
426
  /*
 
427
    seek_not_done is set by my_b_seek() to inform the upcoming read/write
 
428
    operation that a seek needs to be preformed prior to the actual I/O
 
429
    error is 0 if the cache operation was successful, -1 if there was a
 
430
    "hard" error, and the actual number of I/O-ed bytes if the read/write was
 
431
    partial.
 
432
  */
 
433
  int   seek_not_done,error;
 
434
  /* buffer_length is memory size allocated for buffer or write_buffer */
 
435
  size_t        buffer_length;
 
436
  /* read_length is the same as buffer_length except when we use async io */
 
437
  size_t  read_length;
 
438
  myf   myflags;                        /* Flags used to my_read/my_write */
 
439
  /*
 
440
    alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
 
441
    0 if it was supplied by the user.
 
442
    Currently READ_NET is the only one that will use a buffer allocated
 
443
    somewhere else
 
444
  */
 
445
  my_bool alloced_buffer;
 
446
#ifdef HAVE_AIOWAIT
 
447
  /*
 
448
    As inidicated by ifdef, this is for async I/O, which is not currently
 
449
    used (because it's not reliable on all systems)
 
450
  */
 
451
  uint inited;
 
452
  my_off_t aio_read_pos;
 
453
  my_aio_result aio_result;
 
454
#endif
 
455
} IO_CACHE;
281
456
 
282
457
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
283
458
 
302
477
 
303
478
#define my_b_get(info) \
304
479
  ((info)->read_pos != (info)->read_end ?\
305
 
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
 
480
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
306
481
   _my_b_get(info))
307
482
 
308
483
        /* my_b_write_byte dosn't have any err-check */
322
497
  (char*) my_b_get_buffer_start(info)
323
498
#define my_b_get_pos_in_file(info) (info)->pos_in_file
324
499
 
 
500
/* tell write offset in the SEQ_APPEND cache */
 
501
int      my_b_copy_to_file(IO_CACHE *cache, FILE *file);
 
502
my_off_t my_b_append_tell(IO_CACHE* info);
 
503
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
325
504
 
326
505
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
327
506
                                          *(info)->current_pos)
328
507
 
329
 
typedef uint32_t ha_checksum;
 
508
typedef uint32 ha_checksum;
330
509
 
331
510
/* Define the type of function to be passed to process_default_option_files */
332
511
typedef int (*Process_option_func)(void *ctx, const char *group_name,
333
512
                                   const char *option);
334
513
 
335
 
#include <mysys/my_alloc.h>
 
514
#include <my_alloc.h>
336
515
 
337
516
 
338
517
        /* Prototypes for mysys and my_func functions */
339
518
 
340
519
extern int my_copy(const char *from,const char *to,myf MyFlags);
 
520
extern int my_append(const char *from,const char *to,myf MyFlags);
341
521
extern int my_delete(const char *name,myf MyFlags);
342
522
extern int my_getwd(char * buf,size_t size,myf MyFlags);
343
523
extern int my_setwd(const char *dir,myf MyFlags);
 
524
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
344
525
extern void *my_once_alloc(size_t Size,myf MyFlags);
345
526
extern void my_once_free(void);
346
527
extern char *my_once_strdup(const char *src,myf myflags);
348
529
extern File my_open(const char *FileName,int Flags,myf MyFlags);
349
530
extern File my_register_filename(File fd, const char *FileName,
350
531
                                 enum file_type type_of_file,
351
 
                                 uint32_t error_message_number, myf MyFlags);
 
532
                                 uint error_message_number, myf MyFlags);
352
533
extern File my_create(const char *FileName,int CreateFlags,
353
534
                      int AccessFlags, myf MyFlags);
354
535
extern int my_close(File Filedes,myf MyFlags);
362
543
extern int my_delete_with_symlink(const char *name, myf MyFlags);
363
544
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
364
545
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
365
 
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
546
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
 
547
extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
 
548
                     myf MyFlags);
366
549
extern int my_rename(const char *from,const char *to,myf MyFlags);
367
550
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
368
551
extern my_off_t my_tell(File fd,myf MyFlags);
369
 
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
 
552
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
370
553
                     myf MyFlags);
371
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
 
554
extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
 
555
                      my_off_t offset,myf MyFlags);
 
556
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
 
557
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
372
558
                      myf MyFlags);
373
559
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 
560
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
374
561
extern void *_mymalloc(size_t uSize,const char *sFile,
375
 
                       uint32_t uLine, myf MyFlag);
 
562
                       uint uLine, myf MyFlag);
376
563
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
377
 
                       uint32_t uLine, myf MyFlag);
378
 
extern void * my_multi_malloc (myf MyFlags, ...);
379
 
extern void _myfree(void *pPtr, const char *sFile, uint32_t uLine, myf MyFlag);
380
 
extern int _sanity(const char *sFile, uint32_t uLine);
 
564
                       uint uLine, myf MyFlag);
 
565
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
566
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
567
extern int _sanity(const char *sFile, uint uLine);
381
568
extern void *_my_memdup(const void *from, size_t length,
382
 
                        const char *sFile, uint32_t uLine,myf MyFlag);
383
 
extern char * _my_strdup(const char *from, const char *sFile, uint32_t uLine,
 
569
                        const char *sFile, uint uLine,myf MyFlag);
 
570
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
384
571
                         myf MyFlag);
385
572
extern char *_my_strndup(const char *from, size_t length,
386
 
                         const char *sFile, uint32_t uLine,
 
573
                         const char *sFile, uint uLine,
387
574
                         myf MyFlag);
388
575
 
 
576
/* implemented in my_memmem.c */
 
577
extern void *my_memmem(const void *haystack, size_t haystacklen,
 
578
                       const void *needle, size_t needlelen);
 
579
 
 
580
 
389
581
#define my_access access
390
582
extern int check_if_legal_filename(const char *path);
391
583
extern int check_if_legal_tablename(const char *path);
393
585
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
394
586
 
395
587
#ifndef TERMINATE
396
 
extern void TERMINATE(FILE *file, uint32_t flag);
 
588
extern void TERMINATE(FILE *file, uint flag);
397
589
#endif
398
590
extern void init_glob_errs(void);
399
591
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
592
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
400
593
extern int my_fclose(FILE *fd,myf MyFlags);
401
594
extern int my_sync(File fd, myf my_flags);
402
595
extern int my_sync_dir(const char *dir_name, myf my_flags);
403
596
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
404
 
extern void my_error(int nr,myf MyFlags, ...);
405
 
extern void my_printf_error(uint32_t my_err, const char *format,
406
 
                            myf MyFlags, ...)
407
 
  __attribute__((format(printf, 2, 4)));
 
597
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
598
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
599
                                      myf MyFlags, ...))
 
600
                                      ATTRIBUTE_FORMAT(printf, 2, 4);
408
601
extern int my_error_register(const char **errmsgs, int first, int last);
409
602
extern const char **my_error_unregister(int first, int last);
410
 
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
411
 
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
412
 
extern bool my_init(void);
 
603
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
604
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
 
605
extern my_bool my_init(void);
413
606
extern void my_end(int infoflag);
414
607
extern int my_redel(const char *from, const char *to, int MyFlags);
415
608
extern int my_copystat(const char *from, const char *to, int MyFlags);
416
609
extern char * my_filename(File fd);
417
610
 
 
611
#ifndef THREAD
 
612
extern void dont_break(void);
 
613
extern void allow_break(void);
 
614
#else
 
615
#define dont_break()
 
616
#define allow_break()
 
617
#endif
 
618
 
418
619
#ifdef EXTRA_DEBUG
419
620
void my_print_open_files(void);
420
621
#else
421
622
#define my_print_open_files()
422
623
#endif
423
624
 
424
 
extern bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
 
625
extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
425
626
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
426
627
extern void free_tmpdir(MY_TMPDIR *tmpdir);
427
628
 
428
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
629
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
429
630
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
430
631
extern size_t dirname_length(const char *name);
431
632
#define base_name(A) (A+dirname_length(A))
432
633
extern int test_if_hard_path(const char *dir_name);
433
 
extern bool has_path(const char *name);
 
634
extern my_bool has_path(const char *name);
434
635
extern char *convert_dirname(char *to, const char *from, const char *from_end);
435
636
extern void to_unix_path(char * name);
436
637
extern char * fn_ext(const char *name);
437
638
extern char * fn_same(char * toname,const char *name,int flag);
438
639
extern char * fn_format(char * to,const char *name,const char *dir,
439
 
                           const char *form, uint32_t flag);
 
640
                           const char *form, uint flag);
440
641
extern size_t strlength(const char *str);
441
642
extern void pack_dirname(char * to,const char *from);
442
643
extern size_t unpack_dirname(char * to,const char *from);
451
652
extern char * my_load_path(char * to, const char *path,
452
653
                              const char *own_path_prefix);
453
654
extern int wild_compare(const char *str,const char *wildstr,
454
 
                        bool str_is_pattern);
 
655
                        pbool str_is_pattern);
455
656
extern WF_PACK *wf_comp(char * str);
456
657
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
457
658
extern void wf_end(struct wild_file_pack *buffer);
458
 
extern bool array_append_string_unique(const char *str,
 
659
extern size_t strip_sp(char * str);
 
660
extern my_bool array_append_string_unique(const char *str,
459
661
                                          const char **array, size_t size);
460
662
extern void get_date(char * to,int timeflag,time_t use_time);
461
663
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
462
 
                    bool remove_garbage);
 
664
                    pbool remove_garbage);
463
665
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
464
666
                             size_t reclength,enum cache_type type,
465
 
                             bool use_async_io);
466
 
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
 
667
                             pbool use_async_io);
 
668
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
467
669
extern int end_record_cache(RECORD_CACHE *info);
468
670
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
469
 
                              const unsigned char *record,size_t length);
 
671
                              const uchar *record,size_t length);
470
672
extern int flush_write_cache(RECORD_CACHE *info);
471
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
673
extern long my_clock(void);
 
674
extern sig_handler sigtstp_handler(int signal_number);
472
675
extern void handle_recived_signals(void);
473
676
 
474
 
extern RETSIGTYPE my_set_alarm_variable(int signo);
475
 
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
476
 
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
477
 
                                  size_t size_of_element,unsigned char *buffer[]);
478
 
extern RETQSORTTYPE my_qsort(void *base_ptr, size_t total_elems, size_t size,
479
 
                             qsort_cmp cmp);
480
 
extern RETQSORTTYPE my_qsort2(void *base_ptr, size_t total_elems, size_t size,
481
 
                              qsort2_cmp cmp, void *cmp_argument);
 
677
extern sig_handler my_set_alarm_variable(int signo);
 
678
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
679
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
680
                                  size_t size_of_element,uchar *buffer[]);
 
681
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
682
                        qsort_cmp cmp);
 
683
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
684
                         qsort2_cmp cmp, void *cmp_argument);
482
685
extern qsort2_cmp get_ptr_compare(size_t);
483
 
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
484
 
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
 
686
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
687
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
 
688
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
 
689
                         enum cache_type type,my_off_t seek_offset,
 
690
                         pbool use_async_io, myf cache_myflags);
 
691
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
 
692
                               my_off_t seek_offset,pbool use_async_io,
 
693
                               pbool clear_cache);
 
694
extern void setup_io_cache(IO_CACHE* info);
 
695
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
696
#ifdef THREAD
 
697
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
 
698
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
 
699
                                IO_CACHE *write_cache, uint num_threads);
 
700
extern void remove_io_thread(IO_CACHE *info);
 
701
#endif
 
702
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
703
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
704
extern int _my_b_get(IO_CACHE *info);
 
705
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
706
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
707
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
708
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
709
 
 
710
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
 
711
                          size_t Count, my_off_t pos);
 
712
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
 
713
 
 
714
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
 
715
 
 
716
extern int end_io_cache(IO_CACHE *info);
 
717
extern size_t my_b_fill(IO_CACHE *info);
 
718
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
 
719
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
 
720
extern my_off_t my_b_filelength(IO_CACHE *info);
 
721
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
 
722
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
 
723
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
 
724
                                 const char *prefix, size_t cache_size,
 
725
                                 myf cache_myflags);
 
726
extern my_bool real_open_cached_file(IO_CACHE *cache);
 
727
extern void close_cached_file(IO_CACHE *cache);
485
728
File create_temp_file(char *to, const char *dir, const char *pfx,
486
729
                      int mode, myf MyFlags);
487
730
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
488
731
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
489
732
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
490
733
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
491
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
492
 
                                   void *init_buffer, uint32_t init_alloc, 
493
 
                                   uint32_t alloc_increment
 
734
extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
735
                                   void *init_buffer, uint init_alloc, 
 
736
                                   uint alloc_increment
494
737
                                   CALLER_INFO_PROTO);
495
738
/* init_dynamic_array() function is deprecated */
496
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
497
 
                                  uint32_t init_alloc,uint32_t alloc_increment
 
739
extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
740
                                  uint init_alloc,uint alloc_increment
498
741
                                  CALLER_INFO_PROTO);
499
 
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
500
 
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
501
 
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
502
 
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
503
 
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
504
 
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
742
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
743
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
744
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
745
extern my_bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
746
extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
747
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
505
748
extern void delete_dynamic(DYNAMIC_ARRAY *array);
506
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
749
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
507
750
extern void freeze_size(DYNAMIC_ARRAY *array);
508
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
751
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
509
752
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
510
753
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
511
754
#define push_dynamic(A,B) insert_dynamic((A),(B))
512
755
#define reset_dynamic(array) ((array)->elements= 0)
513
756
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
514
757
 
 
758
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
759
                                   size_t init_alloc,size_t alloc_increment);
 
760
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
761
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
762
                          size_t length);
 
763
extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
764
                                       ...);
 
765
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
766
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
767
extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
768
extern void dynstr_free(DYNAMIC_STRING *str);
 
769
#ifdef HAVE_MLOCK
 
770
extern void *my_malloc_lock(size_t length,myf flags);
 
771
extern void my_free_lock(void *ptr,myf flags);
 
772
#else
515
773
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
774
#define my_free_lock(A,B) my_free((A),(B))
 
775
#endif
516
776
#define alloc_root_inited(A) ((A)->min_malloc != 0)
517
777
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
518
778
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
 
779
extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
 
780
                            size_t pre_alloc_size);
 
781
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
 
782
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
 
783
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
 
784
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
 
785
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
 
786
                                size_t prealloc_size);
 
787
extern char *strdup_root(MEM_ROOT *root,const char *str);
 
788
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
 
789
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
519
790
extern int get_defaults_options(int argc, char **argv,
520
791
                                char **defaults, char **extra_defaults,
521
792
                                char **group_suffix);
525
796
                                const char *option_value,
526
797
                                const char *section_name, int remove_option);
527
798
extern int my_search_option_files(const char *conf_file, int *argc,
528
 
                                  char ***argv, uint32_t *args_used,
 
799
                                  char ***argv, uint *args_used,
529
800
                                  Process_option_func func, void *func_ctx);
530
801
extern void free_defaults(char **argv);
531
802
extern void my_print_default_files(const char *conf_file);
532
803
extern void print_defaults(const char *conf_file, const char **groups);
533
 
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
 
804
extern my_bool my_compress(uchar *, size_t *, size_t *);
 
805
extern my_bool my_uncompress(uchar *, size_t , size_t *);
 
806
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
807
                                size_t *complen);
 
808
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
534
809
                               size_t count);
535
 
extern void my_sleep(uint32_t m_seconds);
536
 
extern uint32_t my_set_max_open_files(uint32_t files);
 
810
extern void my_sleep(ulong m_seconds);
 
811
extern ulong crc32(ulong crc, const uchar *buf, uint len);
 
812
extern uint my_set_max_open_files(uint files);
537
813
void my_free_open_file_info(void);
538
814
 
539
815
extern time_t my_time(myf flags);
540
 
extern uint64_t my_getsystime(void);
541
 
extern uint64_t my_micro_time(void);
542
 
extern uint64_t my_micro_time_and_time(time_t *time_arg);
543
 
time_t my_time_possible_from_micro(uint64_t microtime);
544
 
extern bool my_gethwaddr(unsigned char *to);
 
816
extern ulonglong my_getsystime(void);
 
817
extern ulonglong my_micro_time();
 
818
extern ulonglong my_micro_time_and_time(time_t *time_arg);
 
819
time_t my_time_possible_from_micro(ulonglong microtime);
 
820
extern my_bool my_gethwaddr(uchar *to);
 
821
extern int my_getncpus();
545
822
 
546
823
#ifdef HAVE_SYS_MMAN_H
547
824
#include <sys/mman.h>
570
847
#define MAP_NOSYNC       0x0800
571
848
#define MAP_FAILED       ((void *)-1)
572
849
#define MS_SYNC          0x0000
 
850
 
 
851
#ifndef __NETWARE__
573
852
#define HAVE_MMAP
 
853
#endif
574
854
 
575
855
void *my_mmap(void *, size_t, int, int, int, my_off_t);
576
856
int my_munmap(void *, size_t);
577
857
#endif
578
858
 
 
859
/* my_getpagesize */
 
860
#ifdef HAVE_GETPAGESIZE
 
861
#define my_getpagesize()        getpagesize()
 
862
#else
 
863
int my_getpagesize(void);
 
864
#endif
 
865
 
579
866
/* character sets */
580
 
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
581
 
extern uint32_t get_collation_number(const char *name);
582
 
extern const char *get_charset_name(uint32_t cs_number);
583
 
 
584
 
extern const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags);
585
 
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
586
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
587
 
 
588
 
extern bool resolve_charset(const char *cs_name,
589
 
                            const CHARSET_INFO *default_cs,
590
 
                            const CHARSET_INFO **cs);
591
 
extern bool resolve_collation(const char *cl_name,
592
 
                             const CHARSET_INFO *default_cl,
593
 
                             const CHARSET_INFO **cl);
 
867
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
868
extern uint get_collation_number(const char *name);
 
869
extern const char *get_charset_name(uint cs_number);
 
870
 
 
871
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
872
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
 
873
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
 
874
                                           uint cs_flags, myf my_flags);
 
875
 
 
876
extern my_bool resolve_charset(const char *cs_name,
 
877
                               CHARSET_INFO *default_cs,
 
878
                               CHARSET_INFO **cs);
 
879
extern my_bool resolve_collation(const char *cl_name,
 
880
                                 CHARSET_INFO *default_cl,
 
881
                                 CHARSET_INFO **cl);
594
882
 
595
883
extern void free_charsets(void);
596
884
extern char *get_charsets_dir(char *buf);
597
 
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
598
 
extern bool init_compiled_charsets(myf flags);
 
885
extern my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2);
 
886
extern my_bool init_compiled_charsets(myf flags);
599
887
extern void add_compiled_collation(CHARSET_INFO *cs);
600
 
extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
601
 
                                        char *to, size_t to_length,
602
 
                                        const char *from, size_t length);
603
 
extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
604
 
                                        char *to, size_t to_length,
605
 
                                        const char *from, size_t length);
606
 
 
607
 
extern void thd_increment_bytes_sent(uint32_t length);
608
 
extern void thd_increment_bytes_received(uint32_t length);
609
 
extern void thd_increment_net_big_packet_count(uint32_t length);
610
 
 
611
 
#ifdef __cplusplus
612
 
}
613
 
#endif
614
 
 
 
888
extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
 
889
                                      char *to, size_t to_length,
 
890
                                      const char *from, size_t length);
 
891
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
 
892
                                      char *to, size_t to_length,
 
893
                                      const char *from, size_t length);
 
894
 
 
895
extern void thd_increment_bytes_sent(ulong length);
 
896
extern void thd_increment_bytes_received(ulong length);
 
897
extern void thd_increment_net_big_packet_count(ulong length);
 
898
 
 
899
C_MODE_END
615
900
#endif /* _my_sys_h */