1 /* Copyright (c) 2000, 2013, Oracle and/or its affiliates. 2 Copyright (c) 2010, 2022, MariaDB Corporation. 3 4 This program is free software; you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation; version 2 of the License. 7 8 This program is distributed in the hope that it will be useful, 9 but WITHOUT ANY WARRANTY; without even the implied warranty of 10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 GNU General Public License for more details. 12 13 You should have received a copy of the GNU General Public License 14 along with this program; if not, write to the Free Software 15 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ 16 17 #ifndef _my_sys_h 18 #define _my_sys_h 19 20 #include <m_string.h> 21 22 C_MODE_START 23 24 #ifdef HAVE_AIOWAIT 25 #include <sys/asynch.h> /* Used by record-cache */ 26 typedef struct my_aio_result { 27 aio_result_t result; 28 int pending; 29 } my_aio_result; 30 #endif 31 32 #include <my_valgrind.h> 33 34 #include <my_pthread.h> 35 36 #include <m_ctype.h> /* for CHARSET_INFO */ 37 #include <stdarg.h> 38 #include <typelib.h> 39 #ifdef _WIN32 40 #include <malloc.h> /*for alloca*/ 41 #endif 42 #include <mysql/plugin.h> 43 #include <mysql/service_my_print_error.h> 44 45 #define MY_INIT(name) { my_progname= name; my_init(); } 46 47 /** 48 Max length of an error message generated by mysys utilities. 49 Some mysys functions produce error messages. These mostly go 50 to stderr. 51 This constant defines the size of the buffer used to format 52 the message. It should be kept in sync with MYSQL_ERRMSG_SIZE, 53 since sometimes mysys errors are stored in the server diagnostics _debug(const char * fmt,va_list ap)54 area, and we would like to avoid unexpected truncation. 55 */ 56 #define MYSYS_ERRMSG_SIZE (512) 57 #define MYSYS_STRERROR_SIZE (128) 58 59 #define MY_FILE_ERROR ((size_t) -1) 60 61 /* General bitmaps for my_func's */ 62 #define MY_FFNF 1U /* Fatal if file not found */ 63 #define MY_FNABP 2U /* Fatal if not all bytes read/written */ 64 #define MY_NABP 4U /* Error if not all bytes read/written */ 65 #define MY_FAE 8U /* Fatal if any error */ 66 #define MY_WME 16U /* Write message on error */ 67 #define MY_WAIT_IF_FULL 32U /* Wait and try again if disk full error */ 68 #define MY_IGNORE_BADFD 32U /* my_sync(): ignore 'bad descriptor' errors */ 69 #define MY_ENCRYPT 64U /* Encrypt IO_CACHE temporary files */ 70 #define MY_TEMPORARY 64U /* create_temp_file(): delete file at once */ 71 #define MY_NOSYMLINKS 512U /* my_open(): don't follow symlinks */ 72 #define MY_FULL_IO 512U /* my_read(): loop until I/O is complete */ 73 #define MY_DONT_CHECK_FILESIZE 128U /* Option to init_io_cache() */ 74 #define MY_LINK_WARNING 32U /* my_redel() gives warning if links */ 75 #define MY_COPYTIME 64U /* my_redel() copies time */ 76 #define MY_DELETE_OLD 256U /* my_create_with_symlink() */ 77 #define MY_RESOLVE_LINK 128U /* my_realpath(); Only resolve links */ 78 #define MY_HOLD_ORIGINAL_MODES 128U /* my_copy() holds to file modes */ 79 #define MY_REDEL_MAKE_BACKUP 256U 80 #define MY_SEEK_NOT_DONE 32U /* my_lock may have to do a seek */ 81 #define MY_SHORT_WAIT 64U /* my_lock() don't wait if can't lock */ 82 #define MY_FORCE_LOCK 128U /* use my_lock() even if disable_locking */ 83 #define MY_NO_WAIT 256U /* my_lock() don't wait at all */ 84 /* 85 init_dynamic_array() has init buffer; Internal flag, not to be used by 86 caller. 87 */ 88 #define MY_INIT_BUFFER_USED 256U 89 #define MY_ZEROFILL 32U /* my_malloc(), fill array with zero */ 90 #define MY_ALLOW_ZERO_PTR 64U /* my_realloc() ; zero ptr -> malloc */ 91 #define MY_FREE_ON_ERROR 128U /* my_realloc() ; Free old ptr on error */ 92 #define MY_HOLD_ON_ERROR 256U /* my_realloc() ; Return old ptr on error */ 93 #define MY_DONT_OVERWRITE_FILE 2048U /* my_copy: Don't overwrite file */ 94 #define MY_THREADSAFE 2048U /* my_seek(): lock fd mutex */ 95 #define MY_SYNC 4096U /* my_copy(): sync dst file */ 96 #define MY_SYNC_DIR 32768U /* my_create/delete/rename: sync directory */ 97 #define MY_SYNC_FILESIZE 65536U /* my_sync(): safe sync when file is extended */ 98 #define MY_THREAD_SPECIFIC 0x10000U /* my_malloc(): thread specific */ 99 #define MY_THREAD_MOVE 0x20000U /* realloc(); Memory can move */ 100 /* Tree that should delete things automatically */ 101 #define MY_TREE_WITH_DELETE 0x40000U 102 103 #define MY_CHECK_ERROR 1U /* Params to my_end; Check open-close */ 104 #define MY_GIVE_INFO 2U /* Give time info about process*/ 105 #define MY_DONT_FREE_DBUG 4U /* Do not call DBUG_END() in my_end() */ 106 107 #define ME_BELL 4U /* Ring bell then printing message */ 108 #define ME_WAITTANG 0 /* Wait for a user action */ 109 #define ME_NOREFRESH 64U /* Write the error message to error log */ 110 #define ME_NOINPUT 0 /* Don't use the input library */ 111 #define ME_JUST_INFO 1024U /**< not error but just info */ 112 #define ME_JUST_WARNING 2048U /**< not error but just warning */ 113 #define ME_FATALERROR 4096U /* Fatal statement error */ 114 115 /* Bits in last argument to fn_format */ 116 #define MY_REPLACE_DIR 1U /* replace dir in name with 'dir' */ 117 #define MY_REPLACE_EXT 2U /* replace extension with 'ext' */ 118 #define MY_UNPACK_FILENAME 4U /* Unpack name (~ -> home) */ 119 #define MY_PACK_FILENAME 8U /* Pack name (home -> ~) */ 120 #define MY_RESOLVE_SYMLINKS 16U /* Resolve all symbolic links */ 121 #define MY_RETURN_REAL_PATH 32U /* return full path for file */ 122 #define MY_SAFE_PATH 64U /* Return NULL if too long path */ 123 #define MY_RELATIVE_PATH 128U /* name is relative to 'dir' */ 124 #define MY_APPEND_EXT 256U /* add 'ext' as additional extension*/ 125 126 127 /* My seek flags */ 128 #define MY_SEEK_SET 0 129 #define MY_SEEK_CUR 1 130 #define MY_SEEK_END 2 131 132 /* Some constants */ 133 #define MY_WAIT_FOR_USER_TO_FIX_PANIC 60 /* in seconds */ 134 #define MY_WAIT_GIVE_USER_A_MESSAGE 10 /* Every 10 times of prev */ 135 #define MIN_COMPRESS_LENGTH 50 /* Don't compress small bl. */ 136 #define DFLT_INIT_HITS 3 137 138 /* root_alloc flags */ 139 #define MY_KEEP_PREALLOC 1U 140 #define MY_MARK_BLOCKS_FREE 2U /* move used to free list and reuse them */ 141 142 /* Internal error numbers (for assembler functions) */ 143 #define MY_ERRNO_EDOM 33 144 #define MY_ERRNO_ERANGE 34 145 146 /* Bits for get_date timeflag */ 147 #define GETDATE_DATE_TIME 1U 148 #define GETDATE_SHORT_DATE 2U 149 #define GETDATE_HHMMSSTIME 4U 150 #define GETDATE_GMT 8U 151 #define GETDATE_FIXEDLENGTH 16U 152 153 /* Extra length needed for filename if one calls my_create_backup_name */ 154 #define MY_BACKUP_NAME_EXTRA_LENGTH 17 155 156 char *guess_malloc_library(); 157 158 /* If we have our own safemalloc (for debugging) */ 159 #if defined(SAFEMALLOC) 160 void sf_report_leaked_memory(my_thread_id id); 161 int sf_sanity(); 162 extern my_thread_id (*sf_malloc_dbug_id)(void); 163 #define SAFEMALLOC_REPORT_MEMORY(X) sf_report_leaked_memory(X) 164 #else 165 #define SAFEMALLOC_REPORT_MEMORY(X) do {} while(0) 166 #endif 167 168 typedef void (*MALLOC_SIZE_CB) (long long size, my_bool is_thread_specific); 169 extern void set_malloc_size_cb(MALLOC_SIZE_CB func); 170 171 /* defines when allocating data */ 172 extern void *my_malloc(size_t Size,myf MyFlags); 173 extern void *my_multi_malloc(myf MyFlags, ...); 174 extern void *my_multi_malloc_large(myf MyFlags, ...); 175 extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags); 176 extern void my_free(void *ptr); 177 extern void *my_memdup(const void *from,size_t length,myf MyFlags); 178 extern char *my_strdup(const char *from,myf MyFlags); 179 extern char *my_strndup(const char *from, size_t length, myf MyFlags); 180 181 #ifdef HAVE_LINUX_LARGE_PAGES 182 extern uint my_get_large_page_size(void); 183 extern uchar * my_large_malloc(size_t size, myf my_flags); 184 extern void my_large_free(uchar *ptr); 185 #else 186 #define my_get_large_page_size() (0) 187 #define my_large_malloc(A,B) my_malloc_lock((A),(B)) 188 #define my_large_free(A) my_free_lock((A)) 189 #endif /* HAVE_LINUX_LARGE_PAGES */ 190 191 void my_init_atomic_write(void); 192 #ifdef __linux__ 193 my_bool my_test_if_atomic_write(File handle, int pagesize); 194 #else 195 #define my_test_if_atomic_write(A, B) 0 196 #endif /* __linux__ */ 197 extern my_bool my_may_have_atomic_write; 198 199 #if defined(HAVE_ALLOCA) && !defined(HAVE_valgrind) 200 #if defined(_AIX) && !defined(__GNUC__) && !defined(_AIX43) 201 #pragma alloca 202 #endif /* _AIX */ 203 #if defined(__MWERKS__) 204 #undef alloca 205 #define alloca _alloca 206 #endif /* __MWERKS__ */ 207 #if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca) 208 #define alloca __builtin_alloca 209 #endif /* GNUC */ 210 #define my_alloca(SZ) alloca((size_t) (SZ)) 211 #define my_afree(PTR) ((void)0) 212 #define MAX_ALLOCA_SZ 4096 213 #define my_safe_alloca(size) (((size) <= MAX_ALLOCA_SZ) ? \ 214 my_alloca(size) : \ 215 my_malloc((size), MYF(MY_THREAD_SPECIFIC|MY_WME))) 216 #define my_safe_afree(ptr, size) \ 217 do { if ((size) > MAX_ALLOCA_SZ) my_free(ptr); } while(0) 218 #else 219 #define my_alloca(SZ) my_malloc(SZ,MYF(MY_FAE)) 220 #define my_afree(PTR) my_free(PTR) 221 #define my_safe_alloca(size) my_alloca(size) 222 #define my_safe_afree(ptr, size) my_afree(ptr) 223 #endif /* HAVE_ALLOCA */ 224 225 #ifndef errno /* did we already get it? */ 226 #ifdef HAVE_ERRNO_AS_DEFINE 227 #include <errno.h> /* errno is a define */ 228 #else 229 extern int errno; /* declare errno */ 230 #endif 231 #endif /* #ifndef errno */ 232 extern char *home_dir; /* Home directory for user */ 233 extern MYSQL_PLUGIN_IMPORT char *mysql_data_home; 234 extern const char *my_progname; /* program-name (printed in errors) */ 235 extern const char *my_progname_short; /* like above but without directory */ 236 extern char curr_dir[]; /* Current directory for user */ 237 extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags); 238 extern void (*fatal_error_handler_hook)(uint my_err, const char *str, 239 myf MyFlags); 240 extern uint my_file_limit; 241 extern ulonglong my_thread_stack_size; 242 extern int sf_leaking_memory; /* set to 1 to disable memleak detection */ 243 244 extern void (*proc_info_hook)(void *, const PSI_stage_info *, PSI_stage_info *, 245 const char *, const char *, const unsigned int); 246 247 #ifdef HAVE_LINUX_LARGE_PAGES 248 extern my_bool my_use_large_pages; 249 extern uint my_large_page_size; 250 #endif 251 252 /* charsets */ 253 #define MY_ALL_CHARSETS_SIZE 2048 254 extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *default_charset_info; 255 extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *all_charsets[MY_ALL_CHARSETS_SIZE]; 256 extern struct charset_info_st compiled_charsets[]; 257 258 /* Collation properties and use statistics */ 259 extern my_bool my_collation_is_known_id(uint id); 260 extern ulonglong my_collation_statistics_get_use_count(uint id); 261 extern const char *my_collation_get_tailoring(uint id); 262 263 /* statistics */ 264 extern ulong my_stream_opened, my_tmp_file_created; 265 extern ulong my_file_total_opened; 266 extern ulong my_sync_count; 267 extern uint mysys_usage_id; 268 extern int32 my_file_opened; 269 extern my_bool my_init_done, my_thr_key_mysys_exists; 270 extern my_bool my_assert; 271 extern my_bool my_assert_on_error; 272 extern myf my_global_flags; /* Set to MY_WME for more error messages */ 273 /* Point to current my_message() */ 274 extern void (*my_sigtstp_cleanup)(void), 275 /* Executed before jump to shell */ 276 (*my_sigtstp_restart)(void); 277 /* Executed when coming from shell */ 278 extern MYSQL_PLUGIN_IMPORT int my_umask; /* Default creation mask */ 279 extern int my_umask_dir, 280 my_recived_signals, /* Signals we have got */ 281 my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */ 282 my_dont_interrupt; /* call remember_intr when set */ 283 extern MYSQL_PLUGIN_IMPORT my_bool my_use_symdir; 284 285 extern ulong my_default_record_cache_size; 286 extern MYSQL_PLUGIN_IMPORT my_bool my_disable_locking; 287 extern my_bool my_disable_async_io, 288 my_disable_flush_key_blocks, my_disable_symlinks; 289 extern my_bool my_disable_sync, my_disable_copystat_in_redel; 290 extern char wild_many,wild_one,wild_prefix; 291 extern const char *charsets_dir; 292 extern my_bool timed_mutexes; 293 294 enum cache_type 295 { 296 TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE, 297 SEQ_READ_APPEND /* sequential read or append */, 298 READ_FIFO, READ_NET}; 299 300 enum flush_type 301 { 302 FLUSH_KEEP, /* flush block and keep it in the cache */ 303 FLUSH_RELEASE, /* flush block and remove it from the cache */ 304 FLUSH_IGNORE_CHANGED, /* remove block from the cache */ 305 /* 306 As my_disable_flush_pagecache_blocks is always 0, the following option 307 is strictly equivalent to FLUSH_KEEP 308 */ 309 FLUSH_FORCE_WRITE, 310 /** 311 @brief like FLUSH_KEEP but return immediately if file is already being 312 flushed (even partially) by another thread; only for page cache, 313 forbidden for key cache. 314 */ 315 FLUSH_KEEP_LAZY 316 }; 317 318 typedef struct st_record_cache /* Used when caching records */ 319 { 320 File file; 321 int rc_seek,error,inited; 322 uint rc_length,read_length,reclength; 323 my_off_t rc_record_pos,end_of_file; 324 uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos; 325 #ifdef HAVE_AIOWAIT 326 int use_async_io; 327 my_aio_result aio_result; 328 #endif 329 enum cache_type type; 330 } RECORD_CACHE; 331 332 enum file_type 333 { 334 UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN, 335 FILE_BY_MKSTEMP, FILE_BY_DUP 336 }; 337 338 struct st_my_file_info 339 { 340 char *name; 341 #ifdef _WIN32 342 HANDLE fhandle; /* win32 file handle */ 343 int oflag; /* open flags, e.g O_APPEND */ 344 #endif 345 enum file_type type; 346 }; 347 348 extern struct st_my_file_info *my_file_info; 349 350 /* Free function pointer */ 351 typedef void (*FREE_FUNC)(void *); 352 353 typedef struct st_dynamic_array 354 { 355 uchar *buffer; 356 uint elements,max_element; 357 uint alloc_increment; 358 uint size_of_element; 359 myf malloc_flags; 360 } DYNAMIC_ARRAY; 361 362 typedef struct st_my_tmpdir 363 { 364 DYNAMIC_ARRAY full_list; 365 char **list; 366 uint cur, max; 367 mysql_mutex_t mutex; 368 } MY_TMPDIR; 369 370 typedef struct st_dynamic_string 371 { 372 char *str; 373 size_t length,max_length,alloc_increment; 374 } DYNAMIC_STRING; 375 376 struct st_io_cache; 377 378 typedef struct st_io_cache_share 379 { 380 mysql_mutex_t mutex; /* To sync on reads into buffer. */ 381 mysql_cond_t cond; /* To wait for signals. */ 382 mysql_cond_t cond_writer; /* For a synchronized writer. */ 383 /* Offset in file corresponding to the first byte of buffer. */ 384 my_off_t pos_in_file; 385 /* If a synchronized write cache is the source of the data. */ 386 struct st_io_cache *source_cache; 387 uchar *buffer; /* The read buffer. */ 388 uchar *read_end; /* Behind last valid byte of buffer. */ 389 int running_threads; /* threads not in lock. */ 390 int total_threads; /* threads sharing the cache. */ 391 int error; /* Last error. */ 392 #ifdef NOT_YET_IMPLEMENTED 393 /* whether the structure should be free'd */ 394 my_bool alloced; 395 #endif 396 } IO_CACHE_SHARE; 397 398 typedef struct st_io_cache /* Used when caching files */ 399 { 400 /* Offset in file corresponding to the first byte of uchar* buffer. */ 401 my_off_t pos_in_file; 402 /* 403 The offset of end of file for READ_CACHE and WRITE_CACHE. 404 For SEQ_READ_APPEND it the maximum of the actual end of file and 405 the position represented by read_end. 406 */ 407 my_off_t end_of_file; 408 /* Points to current read position in the buffer */ 409 uchar *read_pos; 410 /* the non-inclusive boundary in the buffer for the currently valid read */ 411 uchar *read_end; 412 uchar *buffer; /* The read buffer */ 413 /* Used in ASYNC_IO */ 414 uchar *request_pos; 415 416 /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */ 417 uchar *write_buffer; 418 /* 419 Only used in SEQ_READ_APPEND, and points to the current read position 420 in the write buffer. Note that reads in SEQ_READ_APPEND caches can 421 happen from both read buffer (uchar* buffer) and write buffer 422 (uchar* write_buffer). 423 */ 424 uchar *append_read_pos; 425 /* Points to current write position in the write buffer */ 426 uchar *write_pos; 427 /* The non-inclusive boundary of the valid write area */ 428 uchar *write_end; 429 430 /* 431 The lock is for append buffer used in SEQ_READ_APPEND cache 432 need mutex copying from append buffer to read buffer. 433 */ 434 mysql_mutex_t append_buffer_lock; 435 /* 436 The following is used when several threads are reading the 437 same file in parallel. They are synchronized on disk 438 accesses reading the cached part of the file asynchronously. 439 It should be set to NULL to disable the feature. Only 440 READ_CACHE mode is supported. 441 */ 442 IO_CACHE_SHARE *share; 443 444 /* 445 A caller will use my_b_read() macro to read from the cache 446 if the data is already in cache, it will be simply copied with 447 memcpy() and internal variables will be accordinging updated with 448 no functions invoked. However, if the data is not fully in the cache, 449 my_b_read() will call read_function to fetch the data. read_function 450 must never be invoked directly. 451 */ 452 int (*read_function)(struct st_io_cache *,uchar *,size_t); 453 /* 454 Same idea as in the case of read_function, except my_b_write() needs to 455 be replaced with my_b_append() for a SEQ_READ_APPEND cache 456 */ 457 int (*write_function)(struct st_io_cache *,const uchar *,size_t); 458 /* 459 Specifies the type of the cache. Depending on the type of the cache 460 certain operations might not be available and yield unpredicatable 461 results. Details to be documented later 462 */ 463 enum cache_type type; 464 /* 465 Counts the number of times, when we were forced to use disk. We use it to 466 increase the binlog_cache_disk_use and binlog_stmt_cache_disk_use status 467 variables. 468 */ 469 ulong disk_writes; 470 char *file_name; /* if used with 'open_cached_file' */ 471 const char *dir; 472 char prefix[3]; 473 File file; /* file descriptor */ 474 475 struct st_io_cache *next_file_user; 476 /* 477 seek_not_done is set by my_b_seek() to inform the upcoming read/write 478 operation that a seek needs to be preformed prior to the actual I/O 479 error is 0 if the cache operation was successful, -1 if there was a 480 "hard" error, and the actual number of I/O-ed bytes if the read/write was 481 partial. 482 */ 483 int seek_not_done,error; 484 /* length of the buffer used for storing un-encrypted data */ 485 size_t buffer_length; 486 /* read_length is the same as buffer_length except when we use async io */ 487 size_t read_length; 488 myf myflags; /* Flags used to my_read/my_write */ 489 /* 490 alloced_buffer is set to the size of the buffer allocated for the IO_CACHE. 491 Includes the overhead(storing key to ecnrypt and decrypt) for encryption. 492 Set to 0 if nothing is allocated. 493 Currently READ_NET is the only one that will use a buffer allocated 494 somewhere else 495 */ 496 size_t alloced_buffer; 497 #ifdef HAVE_AIOWAIT 498 /* 499 As inidicated by ifdef, this is for async I/O, which is not currently 500 used (because it's not reliable on all systems) 501 */ 502 uint inited; 503 my_off_t aio_read_pos; 504 my_aio_result aio_result; 505 #endif 506 } IO_CACHE; 507 508 typedef int (*qsort2_cmp)(const void *, const void *, const void *); 509 510 typedef void (*my_error_reporter)(enum loglevel level, const char *format, ...) 511 ATTRIBUTE_FORMAT_FPTR(printf, 2, 3); 512 513 extern my_error_reporter my_charset_error_reporter; 514 515 /* inline functions for mf_iocache */ 516 517 extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock); 518 extern int _my_b_get(IO_CACHE *info); 519 extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count); 520 extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count); 521 522 /* Test if buffer is inited */ 523 static inline void my_b_clear(IO_CACHE *info) { info->buffer= 0; } 524 static inline int my_b_inited(IO_CACHE *info) { return MY_TEST(info->buffer); } 525 #define my_b_EOF INT_MIN 526 527 static inline int my_b_read(IO_CACHE *info, uchar *Buffer, size_t Count) 528 { 529 if (info->read_pos + Count <= info->read_end) 530 { 531 memcpy(Buffer, info->read_pos, Count); 532 info->read_pos+= Count; 533 return 0; 534 } 535 return _my_b_read(info, Buffer, Count); 536 } 537 538 static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count) 539 { 540 MEM_CHECK_DEFINED(Buffer, Count); 541 if (info->write_pos + Count <= info->write_end) 542 { 543 if (Count) 544 { 545 memcpy(info->write_pos, Buffer, Count); 546 info->write_pos+= Count; 547 } 548 return 0; 549 } 550 return _my_b_write(info, Buffer, Count); 551 } 552 553 static inline int my_b_get(IO_CACHE *info) 554 { 555 if (info->read_pos != info->read_end) 556 { 557 info->read_pos++; 558 return info->read_pos[-1]; 559 } 560 return _my_b_get(info); 561 } 562 563 static inline my_bool my_b_write_byte(IO_CACHE *info, uchar chr) 564 { 565 MEM_CHECK_DEFINED(&chr, 1); 566 if (info->write_pos >= info->write_end) 567 if (my_b_flush_io_cache(info, 1)) 568 return 1; 569 *info->write_pos++= chr; 570 return 0; 571 } 572 573 /** 574 Fill buffer of the cache. 575 576 @note It assumes that you have already used all characters in the CACHE, 577 independent of the read_pos value! 578 579 @returns 580 0 On error or EOF (info->error = -1 on error) 581 # Number of characters 582 */ 583 static inline size_t my_b_fill(IO_CACHE *info) 584 { 585 info->read_pos= info->read_end; 586 return _my_b_read(info,0,0) ? 0 : (size_t) (info->read_end - info->read_pos); 587 } 588 589 static inline my_off_t my_b_tell(const IO_CACHE *info) 590 { 591 if (info->type == WRITE_CACHE) { 592 return info->pos_in_file + (my_off_t)(info->write_pos - info->request_pos); 593 594 } 595 return info->pos_in_file + (my_off_t) (info->read_pos - info->request_pos); 596 } 597 598 static inline my_off_t my_b_write_tell(const IO_CACHE *info) 599 { 600 return info->pos_in_file + (my_off_t) (info->write_pos - info->write_buffer); 601 } 602 603 static inline uchar* my_b_get_buffer_start(const IO_CACHE *info) 604 { 605 return info->request_pos; 606 } 607 608 static inline size_t my_b_get_bytes_in_buffer(const IO_CACHE *info) 609 { 610 return (size_t) (info->read_end - info->request_pos); 611 } 612 613 static inline my_off_t my_b_get_pos_in_file(const IO_CACHE *info) 614 { 615 return info->pos_in_file; 616 } 617 618 static inline size_t my_b_bytes_in_cache(const IO_CACHE *info) 619 { 620 if (info->type == WRITE_CACHE) { 621 return (size_t) (info->write_end - info->write_pos); 622 } 623 return (size_t) (info->read_end - info->read_pos); 624 } 625 626 int my_b_copy_to_file (IO_CACHE *cache, FILE *file, size_t count); 627 int my_b_copy_all_to_file(IO_CACHE *cache, FILE *file); 628 629 my_off_t my_b_append_tell(IO_CACHE* info); 630 my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */ 631 int my_b_pread(IO_CACHE *info, uchar *Buffer, size_t Count, my_off_t pos); 632 633 typedef uint32 ha_checksum; 634 635 extern int (*mysys_test_invalid_symlink)(const char *filename); 636 #include <my_alloc.h> 637 638 /* Prototypes for mysys and my_func functions */ 639 640 extern int my_copy(const char *from,const char *to,myf MyFlags); 641 extern int my_delete(const char *name,myf MyFlags); 642 extern int my_rmtree(const char *name, myf Myflags); 643 extern int my_getwd(char * buf,size_t size,myf MyFlags); 644 extern int my_setwd(const char *dir,myf MyFlags); 645 extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags); 646 extern void *my_once_alloc(size_t Size,myf MyFlags); 647 extern void my_once_free(void); 648 extern char *my_once_strdup(const char *src,myf myflags); 649 extern void *my_once_memdup(const void *src, size_t len, myf myflags); 650 extern File my_open(const char *FileName,int Flags,myf MyFlags); 651 extern File my_register_filename(File fd, const char *FileName, 652 enum file_type type_of_file, 653 uint error_message_number, myf MyFlags); 654 extern File my_create(const char *FileName,int CreateFlags, 655 int AccessFlags, myf MyFlags); 656 extern int my_close(File Filedes,myf MyFlags); 657 extern int my_mkdir(const char *dir, int Flags, myf MyFlags); 658 extern int my_readlink(char *to, const char *filename, myf MyFlags); 659 extern int my_is_symlink(const char *filename); 660 extern int my_realpath(char *to, const char *filename, myf MyFlags); 661 extern File my_create_with_symlink(const char *linkname, const char *filename, 662 int createflags, int access_flags, 663 myf MyFlags); 664 extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags); 665 extern int my_symlink(const char *content, const char *linkname, myf MyFlags); 666 extern int my_handler_delete_with_symlink(const char *filename, myf sync_dir); 667 668 extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags); 669 extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset, 670 myf MyFlags); 671 extern int my_rename(const char *from,const char *to,myf MyFlags); 672 extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags); 673 extern my_off_t my_tell(File fd,myf MyFlags); 674 extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count, 675 myf MyFlags); 676 extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count, 677 my_off_t offset,myf MyFlags); 678 extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags); 679 extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count, 680 myf MyFlags); 681 extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags); 682 extern my_off_t my_ftell(FILE *stream,myf MyFlags); 683 684 /* implemented in my_memmem.c */ 685 extern void *my_memmem(const void *haystack, size_t haystacklen, 686 const void *needle, size_t needlelen); 687 688 689 #ifdef _WIN32 690 extern int my_access(const char *path, int amode); 691 #define my_check_user(A,B) (NULL) 692 #define my_set_user(A,B,C) (0) 693 #else 694 #define my_access access 695 struct passwd *my_check_user(const char *user, myf MyFlags); 696 int my_set_user(const char *user, struct passwd *user_info, myf MyFlags); 697 #endif 698 699 extern int check_if_legal_filename(const char *path); 700 extern int check_if_legal_tablename(const char *path); 701 702 #ifdef __WIN__ 703 extern my_bool is_filename_allowed(const char *name, size_t length, 704 my_bool allow_current_dir); 705 #else /* __WIN__ */ 706 # define is_filename_allowed(name, length, allow_cwd) (TRUE) 707 #endif /* __WIN__ */ 708 709 #ifdef _WIN32 710 /* Windows-only functions (CRT equivalents)*/ 711 extern HANDLE my_get_osfhandle(File fd); 712 extern void my_osmaperr(unsigned long last_error); 713 #endif 714 715 extern void init_glob_errs(void); 716 extern const char** get_global_errmsgs(int nr); 717 extern void wait_for_free_space(const char *filename, int errors); 718 extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags); 719 extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags); 720 extern FILE *my_freopen(const char *path, const char *mode, FILE *stream); 721 extern int my_fclose(FILE *fd,myf MyFlags); 722 extern int my_vfprintf(FILE *stream, const char* format, va_list args); 723 extern const char* my_strerror(char *buf, size_t len, int nr); 724 extern int my_fprintf(FILE *stream, const char* format, ...); 725 extern File my_fileno(FILE *fd); 726 extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags); 727 extern int my_chmod(const char *name, mode_t mode, myf my_flags); 728 extern const char *my_basename(const char *filename); 729 extern void thr_set_sync_wait_callback(void (*before_sync)(void), 730 void (*after_sync)(void)); 731 extern int my_sync(File fd, myf my_flags); 732 extern int my_sync_dir(const char *dir_name, myf my_flags); 733 extern int my_sync_dir_by_file(const char *file_name, myf my_flags); 734 extern const char *my_get_err_msg(uint nr); 735 extern int my_error_register(const char** (*get_errmsgs) (int nr), 736 uint first, uint last); 737 extern my_bool my_error_unregister(uint first, uint last); 738 extern void my_message(uint my_err, const char *str,myf MyFlags); 739 extern void my_message_stderr(uint my_err, const char *str, myf MyFlags); 740 extern my_bool my_init(void); 741 extern void my_end(int infoflag); 742 extern int my_redel(const char *from, const char *to, time_t backup_time_stamp, 743 myf MyFlags); 744 void my_create_backup_name(char *to, const char *from, 745 time_t backup_time_stamp); 746 extern int my_copystat(const char *from, const char *to, int MyFlags); 747 extern char * my_filename(File fd); 748 749 extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist); 750 extern char *my_tmpdir(MY_TMPDIR *tmpdir); 751 extern void free_tmpdir(MY_TMPDIR *tmpdir); 752 753 extern void my_remember_signal(int signal_number,sig_handler (*func)(int)); 754 extern size_t dirname_part(char * to,const char *name, size_t *to_res_length); 755 extern size_t dirname_length(const char *name); 756 #define base_name(A) (A+dirname_length(A)) 757 extern int test_if_hard_path(const char *dir_name); 758 extern my_bool has_path(const char *name); 759 extern char *convert_dirname(char *to, const char *from, const char *from_end); 760 extern void to_unix_path(char * name); 761 extern char * fn_ext(const char *name); 762 extern char * fn_ext2(const char *name); 763 extern char * fn_same(char * toname,const char *name,int flag); 764 extern char * fn_format(char * to,const char *name,const char *dir, 765 const char *form, uint flag); 766 extern size_t strlength(const char *str); 767 extern void pack_dirname(char * to,const char *from); 768 extern size_t normalize_dirname(char * to, const char *from); 769 extern size_t unpack_dirname(char * to,const char *from); 770 extern size_t cleanup_dirname(char * to,const char *from); 771 extern size_t system_filename(char * to,const char *from); 772 extern size_t unpack_filename(char * to,const char *from); 773 extern char * intern_filename(char * to,const char *from); 774 extern int pack_filename(char * to, const char *name, size_t max_length); 775 extern char * my_path(char * to,const char *progname, 776 const char *own_pathname_part); 777 extern char * my_load_path(char * to, const char *path, 778 const char *own_path_prefix); 779 extern int wild_compare(const char *str,const char *wildstr, 780 pbool str_is_pattern); 781 extern my_bool array_append_string_unique(const char *str, 782 const char **array, size_t size); 783 extern void get_date(char * to,int timeflag,time_t use_time); 784 extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr, 785 pbool remove_garbage); 786 extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file, 787 size_t reclength,enum cache_type type, 788 pbool use_async_io); 789 extern int read_cache_record(RECORD_CACHE *info,uchar *to); 790 extern int end_record_cache(RECORD_CACHE *info); 791 extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos, 792 const uchar *record,size_t length); 793 extern int flush_write_cache(RECORD_CACHE *info); 794 extern void handle_recived_signals(void); 795 796 extern sig_handler my_set_alarm_variable(int signo); 797 extern my_bool radixsort_is_appliccable(uint n_items, size_t size_of_element); 798 extern void my_string_ptr_sort(uchar *base,uint items,size_t size); 799 extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements, 800 size_t size_of_element,uchar *buffer[]); 801 extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size, 802 qsort_cmp cmp); 803 extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size, 804 qsort2_cmp cmp, void *cmp_argument); 805 extern qsort2_cmp get_ptr_compare(size_t); 806 void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos); 807 my_off_t my_get_ptr(uchar *ptr, size_t pack_length); 808 extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize, 809 enum cache_type type,my_off_t seek_offset, 810 my_bool use_async_io, myf cache_myflags); 811 extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type, 812 my_off_t seek_offset, my_bool use_async_io, 813 my_bool clear_cache); 814 extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare, 815 IO_CACHE *write_cache, uint num_threads); 816 817 extern int init_slave_io_cache(IO_CACHE *master, IO_CACHE *slave); 818 void end_slave_io_cache(IO_CACHE *cache); 819 void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset); 820 821 extern void remove_io_thread(IO_CACHE *info); 822 extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count); 823 extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count); 824 extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count); 825 826 extern int my_block_write(IO_CACHE *info, const uchar *Buffer, 827 size_t Count, my_off_t pos); 828 829 #define flush_io_cache(info) my_b_flush_io_cache((info),1) 830 831 extern int end_io_cache(IO_CACHE *info); 832 extern void my_b_seek(IO_CACHE *info,my_off_t pos); 833 extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length); 834 extern my_off_t my_b_filelength(IO_CACHE *info); 835 extern my_bool my_b_write_backtick_quote(IO_CACHE *info, const char *str, 836 size_t len); 837 extern my_bool my_b_printf(IO_CACHE *info, const char* fmt, ...); 838 extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap); 839 extern my_bool open_cached_file(IO_CACHE *cache,const char *dir, 840 const char *prefix, size_t cache_size, 841 myf cache_myflags); 842 extern my_bool real_open_cached_file(IO_CACHE *cache); 843 extern void close_cached_file(IO_CACHE *cache); 844 File create_temp_file(char *to, const char *dir, const char *pfx, 845 int mode, myf MyFlags); 846 #define my_init_dynamic_array(A,B,C,D,E) init_dynamic_array2(A,B,NULL,C,D,E) 847 #define my_init_dynamic_array2(A,B,C,D,E,F) init_dynamic_array2(A,B,C,D,E,F) 848 extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint element_size, 849 void *init_buffer, uint init_alloc, 850 uint alloc_increment, myf my_flags); 851 extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void* element); 852 extern void *alloc_dynamic(DYNAMIC_ARRAY *array); 853 extern void *pop_dynamic(DYNAMIC_ARRAY*); 854 extern my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, 855 uint array_index); 856 extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements); 857 extern void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint array_index); 858 extern void delete_dynamic(DYNAMIC_ARRAY *array); 859 extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index); 860 extern void delete_dynamic_with_callback(DYNAMIC_ARRAY *array, FREE_FUNC f); 861 extern void freeze_size(DYNAMIC_ARRAY *array); 862 extern int get_index_dynamic(DYNAMIC_ARRAY *array, void *element); 863 #define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element) 864 #define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index)) 865 #define push_dynamic(A,B) insert_dynamic((A),(B)) 866 #define reset_dynamic(array) ((array)->elements= 0) 867 #define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp)) 868 869 extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str, 870 size_t init_alloc,size_t alloc_increment); 871 extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append); 872 my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append, 873 size_t length); 874 extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append, 875 ...); 876 extern my_bool dynstr_append_quoted(DYNAMIC_STRING *str, 877 const char *append, size_t len, 878 char quote); 879 extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str); 880 extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size); 881 extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n); 882 extern void dynstr_free(DYNAMIC_STRING *str); 883 extern uint32 copy_and_convert_extended(char *to, uint32 to_length, 884 CHARSET_INFO *to_cs, 885 const char *from, uint32 from_length, 886 CHARSET_INFO *from_cs, uint *errors); 887 extern void dynstr_reassociate(DYNAMIC_STRING *str, char **res, size_t *length, 888 size_t *alloc_length); 889 extern uint32 copy_and_convert_extended(char *to, uint32 to_length, 890 CHARSET_INFO *to_cs, 891 const char *from, uint32 from_length, 892 CHARSET_INFO *from_cs, uint *errors); 893 #ifdef HAVE_MLOCK 894 extern void *my_malloc_lock(size_t length,myf flags); 895 extern void my_free_lock(void *ptr); 896 #else 897 #define my_malloc_lock(A,B) my_malloc((A),(B)) 898 #define my_free_lock(A) my_free((A)) 899 #endif 900 #define alloc_root_inited(A) ((A)->min_malloc != 0) 901 #define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8) 902 #define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0) 903 extern void init_alloc_root(MEM_ROOT *mem_root, const char *name, 904 size_t block_size, size_t pre_alloc_size, 905 myf my_flags); 906 extern void *alloc_root(MEM_ROOT *mem_root, size_t Size); 907 extern void *multi_alloc_root(MEM_ROOT *mem_root, ...); 908 extern void free_root(MEM_ROOT *root, myf MyFLAGS); 909 extern void set_prealloc_root(MEM_ROOT *root, char *ptr); 910 extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size, 911 size_t prealloc_size); 912 extern char *strdup_root(MEM_ROOT *root,const char *str); 913 static inline char *safe_strdup_root(MEM_ROOT *root, const char *str) 914 { 915 return str ? strdup_root(root, str) : 0; 916 } 917 extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len); 918 extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len); 919 extern my_bool my_compress(uchar *, size_t *, size_t *); 920 extern my_bool my_uncompress(uchar *, size_t , size_t *); 921 extern uchar *my_compress_alloc(const uchar *packet, size_t *len, 922 size_t *complen); 923 extern void *my_az_allocator(void *dummy, unsigned int items, unsigned int size); 924 extern void my_az_free(void *dummy, void *address); 925 extern int my_compress_buffer(uchar *dest, size_t *destLen, 926 const uchar *source, size_t sourceLen); 927 extern int packfrm(const uchar *, size_t, uchar **, size_t *); 928 extern int unpackfrm(uchar **, size_t *, const uchar *); 929 930 extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem, 931 size_t count); 932 #ifdef DBUG_ASSERT_EXISTS 933 extern void my_debug_put_break_here(void); 934 #else 935 #define my_debug_put_break_here() do {} while(0) 936 #endif 937 938 extern void my_sleep(ulong m_seconds); 939 extern ulong crc32(ulong crc, const uchar *buf, uint len); 940 extern uint my_set_max_open_files(uint files); 941 void my_free_open_file_info(void); 942 943 extern my_bool my_gethwaddr(uchar *to); 944 extern int my_getncpus(void); 945 946 #define HRTIME_RESOLUTION 1000000ULL /* microseconds */ 947 typedef struct {ulonglong val;} my_hrtime_t; 948 void my_time_init(void); 949 extern my_hrtime_t my_hrtime(void); 950 951 #ifdef _WIN32 952 extern my_hrtime_t my_hrtime_coarse(); 953 #else 954 #define my_hrtime_coarse() my_hrtime() 955 #endif 956 957 extern ulonglong my_interval_timer(void); 958 extern ulonglong my_getcputime(void); 959 960 #define microsecond_interval_timer() (my_interval_timer()/1000) 961 #define hrtime_to_time(X) ((X).val/HRTIME_RESOLUTION) 962 #define hrtime_from_time(X) ((ulonglong)((X)*HRTIME_RESOLUTION)) 963 #define hrtime_to_double(X) ((X).val/(double)HRTIME_RESOLUTION) 964 #define hrtime_sec_part(X) ((ulong)((X).val % HRTIME_RESOLUTION)) 965 #define my_time(X) hrtime_to_time(my_hrtime_coarse()) 966 967 #if STACK_DIRECTION < 0 968 #define available_stack_size(CUR,END) (long) ((char*)(CUR) - (char*)(END)) 969 #else 970 #define available_stack_size(CUR,END) (long) ((char*)(END) - (char*)(CUR)) 971 #endif 972 973 #ifdef HAVE_SYS_MMAN_H 974 #ifndef MAP_NOSYNC 975 #define MAP_NOSYNC 0 976 #endif 977 #ifndef MAP_NORESERVE 978 #define MAP_NORESERVE 0 /* For irix and AIX */ 979 #endif 980 981 #ifdef HAVE_MMAP64 982 #define my_mmap(a,b,c,d,e,f) mmap64(a,b,c,d,e,f) 983 #else 984 #define my_mmap(a,b,c,d,e,f) mmap(a,b,c,d,e,f) 985 #endif 986 #define my_munmap(a,b) munmap((a),(b)) 987 988 #else 989 /* not a complete set of mmap() flags, but only those that nesessary */ 990 #define PROT_READ 1 991 #define PROT_WRITE 2 992 #define MAP_NORESERVE 0 993 #define MAP_SHARED 0x0001 994 #define MAP_PRIVATE 0x0002 995 #define MAP_NOSYNC 0x0800 996 #define MAP_FAILED ((void *)-1) 997 #define MS_SYNC 0x0000 998 999 #define HAVE_MMAP 1000 void *my_mmap(void *, size_t, int, int, int, my_off_t); 1001 int my_munmap(void *, size_t); 1002 #endif 1003 1004 /* my_getpagesize */ 1005 #ifdef HAVE_GETPAGESIZE 1006 #define my_getpagesize() getpagesize() 1007 #else 1008 int my_getpagesize(void); 1009 #endif 1010 1011 int my_msync(int, void *, size_t, int); 1012 1013 #define MY_UUID_SIZE 16 1014 #define MY_UUID_STRING_LENGTH (8+1+4+1+4+1+4+1+12) 1015 1016 void my_uuid_init(ulong seed1, ulong seed2); 1017 void my_uuid(uchar *guid); 1018 void my_uuid2str(const uchar *guid, char *s); 1019 void my_uuid_end(void); 1020 1021 const char *my_dlerror(const char *dlpath); 1022 1023 /* character sets */ 1024 extern void my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader); 1025 extern uint get_charset_number(const char *cs_name, uint cs_flags); 1026 extern uint get_collation_number(const char *name); 1027 extern const char *get_charset_name(uint cs_number); 1028 1029 extern CHARSET_INFO *get_charset(uint cs_number, myf flags); 1030 extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags); 1031 extern CHARSET_INFO *my_collation_get_by_name(MY_CHARSET_LOADER *loader, 1032 const char *name, myf flags); 1033 extern CHARSET_INFO *get_charset_by_csname(const char *cs_name, 1034 uint cs_flags, myf my_flags); 1035 extern CHARSET_INFO *my_charset_get_by_name(MY_CHARSET_LOADER *loader, 1036 const char *name, 1037 uint cs_flags, myf my_flags); 1038 extern my_bool resolve_charset(const char *cs_name, 1039 CHARSET_INFO *default_cs, 1040 CHARSET_INFO **cs); 1041 extern my_bool resolve_collation(const char *cl_name, 1042 CHARSET_INFO *default_cl, 1043 CHARSET_INFO **cl); 1044 extern void free_charsets(void); 1045 extern char *get_charsets_dir(char *buf); 1046 extern my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2); 1047 extern my_bool init_compiled_charsets(myf flags); 1048 extern void add_compiled_collation(struct charset_info_st *cs); 1049 extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info, 1050 char *to, size_t to_length, 1051 const char *from, size_t length); 1052 extern char *get_tty_password(const char *opt_message); 1053 #ifdef __WIN__ 1054 #define BACKSLASH_MBTAIL 1055 /* File system character set */ 1056 extern CHARSET_INFO *fs_character_set(void); 1057 #endif 1058 extern const char *my_default_csname(void); 1059 extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info, 1060 char *to, size_t to_length, 1061 const char *from, size_t length); 1062 1063 extern void thd_increment_bytes_sent(void *thd, size_t length); 1064 extern void thd_increment_bytes_received(void *thd, size_t length); 1065 extern void thd_increment_net_big_packet_count(void *thd, size_t length); 1066 1067 #ifdef __WIN__ 1068 extern my_bool have_tcpip; /* Is set if tcpip is used */ 1069 1070 /* implemented in my_windac.c */ 1071 1072 int my_security_attr_create(SECURITY_ATTRIBUTES **psa, const char **perror, 1073 DWORD owner_rights, DWORD everybody_rights); 1074 1075 void my_security_attr_free(SECURITY_ATTRIBUTES *sa); 1076 1077 /* implemented in my_conio.c */ 1078 char* my_cgets(char *string, size_t clen, size_t* plen); 1079 1080 #endif 1081 1082 #include <mysql/psi/psi.h> 1083 1084 #ifdef HAVE_PSI_INTERFACE 1085 extern MYSQL_PLUGIN_IMPORT struct PSI_bootstrap *PSI_hook; 1086 extern void set_psi_server(PSI *psi); 1087 void my_init_mysys_psi_keys(void); 1088 #endif 1089 1090 struct st_mysql_file; 1091 extern struct st_mysql_file *mysql_stdin; 1092 C_MODE_END 1093 #endif /* _my_sys_h */ 1094