← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_sys.h

pandora-build v0.71. Added check for avahi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_sys.h
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#ifndef DRIZZLED_INTERNAL_MY_SYS_H
22
 
#define DRIZZLED_INTERNAL_MY_SYS_H
23
 
 
24
 
#ifdef __cplusplus
25
 
# include <cstdio>
26
 
#else
27
 
# include <stdio.h>
28
 
#endif
 
21
#ifndef MYSYS_MY_SYS_H
 
22
#define MYSYS_MY_SYS_H
29
23
 
30
24
#include <errno.h>
31
 
 
32
 
#include "drizzled/internal/my_pthread.h"
33
 
 
34
 
#include "drizzled/charset_info.h"                    /* for CHARSET_INFO */
 
25
#define my_errno (errno)
 
26
 
 
27
#include <mysys/my_pthread.h>
 
28
 
 
29
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
35
30
#include <stdarg.h>
36
 
#include "drizzled/typelib.h"
37
 
#include "drizzled/internal/aio_result.h"
38
 
 
39
 
#include "drizzled/memory/root.h"
40
 
#include "drizzled/error.h"
41
 
 
42
 
#ifndef errno                           /* did we already get it? */
43
 
#ifdef HAVE_ERRNO_AS_DEFINE
44
 
#include <errno.h>                      /* errno is a define */
45
 
#else
46
 
extern int errno;                       /* declare errno */
47
 
#endif
48
 
#endif                                  /* #ifndef errno */
49
 
 
50
 
#include <drizzled/dynamic_array.h>
51
 
 
52
 
#ifdef HAVE_SYS_MMAN_H 
53
 
#include <sys/mman.h>
54
 
#endif
55
 
 
56
 
#include "drizzled/qsort_cmp.h"
57
 
 
58
 
namespace drizzled
59
 
{
60
 
namespace internal
61
 
{
62
 
 
63
 
#ifndef MAP_NOSYNC
64
 
#define MAP_NOSYNC      0
65
 
#endif
66
 
#ifndef MAP_NORESERVE
67
 
#define MAP_NORESERVE 0         /* For irix and AIX */
68
 
#endif
69
 
 
70
 
/*
71
 
  EDQUOT is used only in 3 C files only in mysys/. If it does not exist on
72
 
  system, we set it to some value which can never happen.
73
 
*/
74
 
#ifndef EDQUOT
75
 
#define EDQUOT (-1)
76
 
#endif
 
31
#include <mysys/typelib.h>
 
32
#include <mysys/aio_result.h>
 
33
 
 
34
#include <mysys/my_alloc.h>
77
35
 
78
36
/* Sun Studio does not inject this into main namespace yet */
79
37
#if defined(__cplusplus)
80
38
  using std::FILE;
81
39
#endif
82
40
 
83
 
#define MY_INIT(name);          { ::drizzled::internal::my_progname= name; ::drizzled::internal::my_init(); }
 
41
#define MY_INIT(name);          { my_progname= name; my_init(); }
84
42
 
 
43
/* Max width of screen (for error messages) */
 
44
#define SC_MAXWIDTH 256
 
45
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
 
46
#define NRERRBUFFS      (2)     /* Buffers for parameters */
 
47
#define MY_FILE_ERROR   ((size_t) -1)
85
48
 
86
49
        /* General bitmaps for my_func's */
87
50
#define MY_FFNF         1       /* Fatal if file not found */
103
66
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
104
67
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
105
68
 
 
69
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
 
70
#define MY_GIVE_INFO    2       /* Give time info about process*/
 
71
 
 
72
#define ME_HIGHBYTE     8       /* Shift for colours */
 
73
#define ME_NOCUR        1       /* Don't use curses message */
106
74
#define ME_OLDWIN       2       /* Use old window */
107
75
#define ME_BELL         4       /* Ring bell then printing message */
108
76
#define ME_HOLDTANG     8       /* Don't delete last keys */
 
77
#define ME_WAITTOT      16      /* Wait for errtime secs of for a action */
109
78
#define ME_WAITTANG     32      /* Wait for a user action  */
110
79
#define ME_NOREFRESH    64      /* Dont refresh screen */
111
80
#define ME_NOINPUT      128     /* Dont use the input libary */
 
81
#define ME_COLOUR1      ((1 << ME_HIGHBYTE))    /* Possibly error-colours */
 
82
#define ME_COLOUR2      ((2 << ME_HIGHBYTE))
 
83
#define ME_COLOUR3      ((3 << ME_HIGHBYTE))
 
84
#define ME_FATALERROR   1024    /* Fatal statement error */
112
85
 
113
86
        /* Bits in last argument to fn_format */
114
87
#define MY_REPLACE_DIR          1       /* replace dir in name with 'dir' */
115
88
#define MY_REPLACE_EXT          2       /* replace extension with 'ext' */
116
89
#define MY_UNPACK_FILENAME      4       /* Unpack name (~ -> home) */
 
90
#define MY_PACK_FILENAME        8       /* Pack name (home -> ~) */
117
91
#define MY_RESOLVE_SYMLINKS     16      /* Resolve all symbolic links */
118
92
#define MY_RETURN_REAL_PATH     32      /* return full path for file */
119
93
#define MY_SAFE_PATH            64      /* Return NULL if too long path */
126
100
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
127
101
#define DFLT_INIT_HITS  3
128
102
 
 
103
        /* root_alloc flags */
 
104
#define MY_KEEP_PREALLOC        1
 
105
#define MY_MARK_BLOCKS_FREE     2  /* move used to free list and reuse them */
 
106
 
129
107
        /* Internal error numbers (for assembler functions) */
130
108
#define MY_ERRNO_EDOM           33
131
109
#define MY_ERRNO_ERANGE         34
137
115
#define GETDATE_GMT             8
138
116
#define GETDATE_FIXEDLENGTH     16
139
117
 
140
 
 
141
 
typedef uint64_t my_off_t;
 
118
        /* defines when allocating data */
 
119
#undef TERMINATE
 
120
#define TERMINATE(A,B) {}
 
121
 
 
122
#ifdef __cplusplus
 
123
extern "C" {
 
124
#endif
 
125
 
 
126
typedef int  (*qsort_cmp)(const void *,const void *);
 
127
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
142
128
 
143
129
#define TRASH(A,B) /* nothing */
144
130
 
 
131
#ifndef errno                           /* did we already get it? */
 
132
#ifdef HAVE_ERRNO_AS_DEFINE
 
133
#include <errno.h>                      /* errno is a define */
 
134
#else
 
135
extern int errno;                       /* declare errno */
 
136
#endif
 
137
#endif                                  /* #ifndef errno */
145
138
extern char *home_dir;                  /* Home directory for user */
146
139
extern const char *my_progname;         /* program-name (printed in errors) */
 
140
typedef void (*error_handler_func)(uint32_t my_err, const char *str,myf MyFlags);
 
141
extern error_handler_func error_handler_hook;
147
142
extern uint32_t my_file_limit;
148
143
 
 
144
/* charsets */
 
145
extern const CHARSET_INFO *default_charset_info;
 
146
extern CHARSET_INFO *all_charsets[256];
 
147
extern CHARSET_INFO compiled_charsets[];
 
148
 
149
149
/* statistics */
 
150
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
 
151
extern uint32_t    my_file_total_opened;
150
152
extern uint     mysys_usage_id;
151
153
extern bool     my_init_done;
152
154
 
 
155
typedef void (*void_ptr_func)(void);
 
156
typedef void (*void_ptr_int_func)(int);
 
157
 
 
158
                                        /* Point to current my_message() */
 
159
extern void_ptr_func my_sigtstp_cleanup,
 
160
                                        /* Executed before jump to shell */
 
161
            my_sigtstp_restart;
153
162
                                        /* Executed when comming from shell */
154
163
extern int my_umask,            /* Default creation mask  */
155
164
           my_umask_dir,
171
180
 
172
181
extern bool timed_mutexes;
173
182
 
174
 
typedef class wild_file_pack    /* Struct to hold info when selecting files */
 
183
typedef struct wild_file_pack   /* Struct to hold info when selecting files */
175
184
{
176
 
public:
177
185
  uint          wilds;          /* How many wildcards */
178
186
  uint          not_pos;        /* Start of not-theese-files */
179
187
  char *        *wild;          /* Pointer to wildcards */
180
 
 
181
 
  wild_file_pack():
182
 
    wilds(0),
183
 
    not_pos(0),
184
 
    wild(NULL)
185
 
  {}
186
 
 
187
188
} WF_PACK;
188
189
 
 
190
enum loglevel {
 
191
   ERROR_LEVEL,
 
192
   WARNING_LEVEL,
 
193
   INFORMATION_LEVEL
 
194
};
 
195
 
189
196
enum cache_type
190
197
{
191
 
  TYPE_NOT_SET= 0,
192
 
  READ_CACHE,
193
 
  WRITE_CACHE,
194
 
  READ_FIFO,
195
 
  READ_NET,
196
 
  WRITE_NET
197
 
};
 
198
  TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
 
199
  SEQ_READ_APPEND               /* sequential read or append */,
 
200
  READ_FIFO, READ_NET,WRITE_NET};
198
201
 
199
 
typedef struct record_cache     /* Used when cacheing records */
 
202
typedef struct st_record_cache  /* Used when cacheing records */
200
203
{
201
 
public:
202
 
  int file;
 
204
  File file;
203
205
  int   rc_seek,error,inited;
204
206
  uint  rc_length,read_length,reclength;
205
207
  my_off_t rc_record_pos,end_of_file;
209
211
  my_aio_result aio_result;
210
212
#endif
211
213
  enum cache_type type;
212
 
 
213
 
  record_cache():
214
 
    file(0),
215
 
    rc_seek(0),
216
 
    error(0),
217
 
    inited(0),
218
 
    rc_length(0),
219
 
    read_length(0),
220
 
    reclength(0),
221
 
    rc_record_pos(0),
222
 
    end_of_file(0),
223
 
    rc_buff(NULL),
224
 
    rc_buff2(NULL),
225
 
    rc_pos(NULL),
226
 
    rc_end(NULL),
227
 
    rc_request_pos(NULL)
228
 
  {}
229
 
 
230
214
} RECORD_CACHE;
231
215
 
232
216
 
 
217
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
 
218
 
233
219
        /* defines for mf_iocache */
234
220
 
235
221
        /* Test if buffer is inited */
257
243
#define my_b_tell(info) ((info)->pos_in_file + \
258
244
                         (size_t) (*(info)->current_pos - (info)->request_pos))
259
245
 
 
246
#define my_b_get_buffer_start(info) (info)->request_pos
 
247
 
 
248
 
260
249
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
261
250
                                          *(info)->current_pos)
262
251
 
269
258
int handle_default_option(void *in_ctx, const char *group_name,
270
259
                          const char *option);
271
260
 
 
261
#include <mysys/my_alloc.h>
272
262
 
273
263
 
274
264
        /* Prototypes for mysys and my_func functions */
275
265
 
276
266
extern int my_copy(const char *from,const char *to,myf MyFlags);
277
267
extern int my_delete(const char *name,myf MyFlags);
278
 
extern int my_open(const char *FileName,int Flags,myf MyFlags);
279
 
extern int my_register_filename(int fd, const char *FileName,
 
268
extern File my_open(const char *FileName,int Flags,myf MyFlags);
 
269
extern File my_register_filename(File fd, const char *FileName,
280
270
                                 uint32_t error_message_number, myf MyFlags);
281
 
extern int my_create(const char *FileName,int CreateFlags,
 
271
extern File my_create(const char *FileName,int CreateFlags,
282
272
                      int AccessFlags, myf MyFlags);
283
 
extern int my_close(int Filedes,myf MyFlags);
 
273
extern int my_close(File Filedes,myf MyFlags);
284
274
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
285
275
extern int my_realpath(char *to, const char *filename, myf MyFlags);
286
 
extern int my_create_with_symlink(const char *linkname, const char *filename,
 
276
extern File my_create_with_symlink(const char *linkname, const char *filename,
287
277
                                   int createflags, int access_flags,
288
278
                                   myf MyFlags);
289
279
extern int my_delete_with_symlink(const char *name, myf MyFlags);
290
280
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
291
 
extern size_t my_read(int Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
281
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
292
282
extern int my_rename(const char *from,const char *to,myf MyFlags);
293
 
extern size_t my_write(int Filedes,const unsigned char *Buffer,size_t Count,
 
283
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
294
284
                     myf MyFlags);
295
285
extern int _sanity(const char *sFile, uint32_t uLine);
296
286
 
 
287
#define my_access access
297
288
extern int check_if_legal_filename(const char *path);
298
289
extern int check_if_legal_tablename(const char *path);
299
290
 
300
291
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
301
292
 
302
 
extern int my_sync(int fd, myf my_flags);
 
293
#ifndef TERMINATE
 
294
extern void TERMINATE(FILE *file, uint32_t flag);
 
295
#endif
 
296
extern void init_glob_errs(void);
 
297
extern int my_sync(File fd, myf my_flags);
303
298
extern int my_sync_dir(const char *dir_name, myf my_flags);
304
299
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
 
300
extern void my_error(int nr,myf MyFlags, ...);
 
301
extern void my_printf_error(uint32_t my_err, const char *format,
 
302
                            myf MyFlags, ...)
 
303
  __attribute__((format(printf, 2, 4)));
 
304
extern int my_error_register(const char **errmsgs, int first, int last);
 
305
extern const char **my_error_unregister(int first, int last);
 
306
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
 
307
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
305
308
extern bool my_init(void);
306
 
extern void my_end(void);
 
309
extern void my_end(int infoflag);
307
310
extern int my_redel(const char *from, const char *to, int MyFlags);
308
311
extern int my_copystat(const char *from, const char *to, int MyFlags);
309
 
extern char * my_filename(int fd);
 
312
extern char * my_filename(File fd);
 
313
 
 
314
#ifdef EXTRA_DEBUG
 
315
void my_print_open_files(void);
 
316
#else
 
317
#define my_print_open_files()
 
318
#endif
310
319
 
311
320
extern void my_remember_signal(int signal_number,void (*func)(int));
312
321
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
329
338
extern int wild_compare(const char *str,const char *wildstr,
330
339
                        bool str_is_pattern);
331
340
extern WF_PACK *wf_comp(char * str);
332
 
extern int wf_test(wild_file_pack *wf_pack,const char *name);
333
 
extern void wf_end(wild_file_pack *buffer);
 
341
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
 
342
extern void wf_end(struct wild_file_pack *buffer);
334
343
extern bool array_append_string_unique(const char *str,
335
344
                                          const char **array, size_t size);
336
345
extern void get_date(char * to,int timeflag,time_t use_time);
337
 
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,int file,
 
346
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
338
347
                             size_t reclength,enum cache_type type,
339
348
                             bool use_async_io);
340
349
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
356
365
extern qsort2_cmp get_ptr_compare(size_t);
357
366
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
358
367
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
359
 
int create_temp_file(char *to, const char *dir, const char *pfx, myf MyFlags);
360
 
 
 
368
File create_temp_file(char *to, const char *dir, const char *pfx, myf MyFlags);
 
369
 
 
370
#include <mysys/dynamic_array.h>
 
371
 
 
372
#define alloc_root_inited(A) ((A)->min_malloc != 0)
 
373
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
361
374
extern int get_defaults_options(int argc, char **argv,
362
375
                                char **defaults, char **extra_defaults,
363
376
                                char **group_suffix);
373
386
                               size_t count);
374
387
extern void my_sleep(uint32_t m_seconds);
375
388
 
376
 
 
 
389
extern uint64_t my_getsystime(void);
 
390
extern uint64_t my_micro_time(void);
 
391
extern uint64_t my_micro_time_and_time(time_t *time_arg);
 
392
 
 
393
#ifdef HAVE_SYS_MMAN_H
 
394
#include <sys/mman.h>
 
395
 
 
396
#ifndef MAP_NOSYNC
 
397
#define MAP_NOSYNC      0
 
398
#endif
 
399
#ifndef MAP_NORESERVE
 
400
#define MAP_NORESERVE 0         /* For irix and AIX */
 
401
#endif
 
402
 
 
403
#ifdef HAVE_MMAP64
 
404
#define my_mmap(a,b,c,d,e,f)    mmap64(a,b,c,d,e,f)
 
405
#else
 
406
#define my_mmap(a,b,c,d,e,f)    mmap(a,b,c,d,e,f)
 
407
#endif
 
408
#define my_munmap(a,b)          munmap((a),(b))
 
409
 
 
410
#else
 
411
/* not a complete set of mmap() flags, but only those that nesessary */
 
412
#define PROT_READ        1
 
413
#define PROT_WRITE       2
 
414
#define MAP_NORESERVE    0
 
415
#define MAP_SHARED       0x0001
 
416
#define MAP_PRIVATE      0x0002
 
417
#define MAP_NOSYNC       0x0800
 
418
#define MAP_FAILED       ((void *)-1)
 
419
#define MS_SYNC          0x0000
 
420
#define HAVE_MMAP
 
421
 
 
422
void *my_mmap(void *, size_t, int, int, int, my_off_t);
 
423
int my_munmap(void *, size_t);
 
424
#endif
 
425
 
 
426
/* character sets */
 
427
void *cs_alloc(size_t size);
 
428
 
 
429
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
 
430
extern uint32_t get_collation_number(const char *name);
 
431
extern const char *get_charset_name(uint32_t cs_number);
 
432
 
 
433
extern const CHARSET_INFO *get_charset(uint32_t cs_number);
 
434
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name);
 
435
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);
 
436
 
 
437
extern bool resolve_charset(const char *cs_name,
 
438
                            const CHARSET_INFO *default_cs,
 
439
                            const CHARSET_INFO **cs);
 
440
extern bool resolve_collation(const char *cl_name,
 
441
                             const CHARSET_INFO *default_cl,
 
442
                             const CHARSET_INFO **cl);
 
443
 
 
444
extern void free_charsets(void);
 
445
extern char *get_charsets_dir(char *buf);
 
446
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
 
447
extern bool init_compiled_charsets(myf flags);
 
448
extern void add_compiled_collation(CHARSET_INFO *cs);
 
449
extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
 
450
                                        char *to, size_t to_length,
 
451
                                        const char *from, size_t length);
 
452
extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
 
453
                                        char *to, size_t to_length,
 
454
                                        const char *from, size_t length);
377
455
 
378
456
extern void thd_increment_bytes_sent(uint32_t length);
379
457
extern void thd_increment_bytes_received(uint32_t length);
380
458
extern void thd_increment_net_big_packet_count(uint32_t length);
381
459
 
382
 
} /* namespace internal */
383
 
} /* namespace drizzled */
 
460
#ifdef __cplusplus
 
461
}
 
462
#endif
384
463
 
385
 
#endif /* DRIZZLED_INTERNAL_MY_SYS_H */
 
464
#endif /* MYSYS_MY_SYS_H */