← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/archive/azio.cc

Reverted my change to interval_list

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/archive/azio.cc
11
11
 
12
12
/* @(#) $Id$ */
13
13
 
14
 
#include "config.h"
15
 
 
16
14
#include "azio.h"
17
15
 
18
 
#include <fcntl.h>
 
16
#include <stdio.h>
 
17
#include <string.h>
 
18
#include <stdlib.h>
 
19
#include <assert.h>
19
20
#include <unistd.h>
20
21
 
21
 
#include <cstdio>
22
 
#include <cstring>
23
 
#include <cstdlib>
24
 
#include <cassert>
25
 
 
26
 
using namespace drizzled;
27
 
 
28
22
static int const az_magic[3] = {0xfe, 0x03, 0x01}; /* az magic header */
29
23
 
30
24
static unsigned int azwrite(azio_stream *s, void *buf, unsigned int len);
43
37
static void do_aio_cleanup(azio_stream *s);
44
38
#endif
45
39
 
46
 
extern "C" pthread_handler_t run_task(void *p);
47
 
 
48
 
extern "C" pthread_handler_t run_task(void *p)
 
40
extern "C"
 
41
pthread_handler_t run_task(void *p);
 
42
 
 
43
 
 
44
pthread_handler_t run_task(void *p)
49
45
{
50
46
  int fd;
51
47
  char *buffer;
52
48
  size_t offset;
53
49
  azio_stream *s= (azio_stream *)p;
54
50
 
55
 
  internal::my_thread_init();
 
51
  my_thread_init();
56
52
 
57
53
  while (1)
58
54
  {
77
73
    pthread_mutex_unlock(&s->container.thresh_mutex);
78
74
  }
79
75
 
80
 
  internal::my_thread_end();
 
76
  my_thread_end();
81
77
 
82
78
  return 0;
83
79
}
163
159
  int err;
164
160
  int level = Z_DEFAULT_COMPRESSION ; /* compression level */
165
161
  int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
166
 
  int fd= -1;
 
162
  File fd= -1;
167
163
 
168
164
  memset(s, 0, sizeof(azio_stream));
169
165
 
229
225
  s->stream.avail_out = AZ_BUFSIZE_WRITE;
230
226
 
231
227
  errno = 0;
232
 
  s->file = fd < 0 ? internal::my_open(path, Flags, MYF(0)) : fd;
 
228
  s->file = fd < 0 ? my_open(path, Flags, MYF(0)) : fd;
233
229
#ifdef AZIO_AIO
234
230
  s->container.fd= s->file;
235
231
#endif
441
437
    if (s->mode == 'w')
442
438
    {
443
439
      err = deflateEnd(&(s->stream));
444
 
      internal::my_sync(s->file, MYF(0));
 
440
      my_sync(s->file, MYF(0));
445
441
    }
446
442
    else if (s->mode == 'r')
447
443
      err = inflateEnd(&(s->stream));
449
445
 
450
446
  do_aio_cleanup(s);
451
447
 
452
 
  if (s->file > 0 && internal::my_close(s->file, MYF(0)))
 
448
  if (s->file > 0 && my_close(s->file, MYF(0)))
453
449
      err = Z_ERRNO;
454
450
 
455
451
  s->file= -1;
463
459
  Reads the given number of uncompressed bytes from the compressed file.
464
460
  azread returns the number of bytes actually read (0 for end of file).
465
461
*/
466
 
/*
467
 
   This function is legacy, do not use.
468
 
 
469
 
     Reads the given number of uncompressed bytes from the compressed file.
470
 
   If the input file was not in gzip format, gzread copies the given number
471
 
   of bytes into the buffer.
472
 
     gzread returns the number of uncompressed bytes actually read (0 for
473
 
   end of file, -1 for error).
474
 
*/
475
 
static unsigned int azread_internal( azio_stream *s, voidp buf, unsigned int len, int *error)
 
462
unsigned int azread_internal( azio_stream *s, voidp buf, unsigned int len, int *error)
476
463
{
477
464
  Bytef *start = (Bytef*)buf; /* starting point for crc computation */
478
465
  Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
758
745
    err= do_flush(s, flush);
759
746
 
760
747
    if (err) return err;
761
 
    internal::my_sync(s->file, MYF(0));
 
748
    my_sync(s->file, MYF(0));
762
749
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
763
750
  }
764
751
}
1010
997
/*
1011
998
  Simple comment field
1012
999
*/
1013
 
int azwrite_comment(azio_stream *s, const char *blob, unsigned int length)
 
1000
int azwrite_comment(azio_stream *s, char *blob, unsigned int length)
1014
1001
{
1015
1002
  if (s->mode == 'r')
1016
 
    return -1;
 
1003
    return 1;
1017
1004
 
1018
1005
  if (s->rows > 0)
1019
 
    return -1;
 
1006
    return 1;
1020
1007
 
1021
1008
  s->comment_start_pos= (uint) s->start;
1022
1009
  s->comment_length= length;
1025
1012
  ssize_t r= pwrite(s->file, (unsigned char*) blob,
1026
1013
                    s->comment_length, s->comment_start_pos);
1027
1014
  if (r != (ssize_t)s->comment_length)
1028
 
    return -1;
 
1015
    return r;
1029
1016
 
1030
1017
  write_header(s);
1031
1018
  s->pos= (size_t)lseek(s->file, 0, SEEK_END);
1076
1063
    }
1077
1064
    s->pos+= s->stream.avail_in;
1078
1065
    s->inbuf= (Byte *)s->container.buffer;
1079
 
    /* We only azio_read when we know there is more data to be read */
 
1066
    /* We only aio_read when we know there is more data to be read */
1080
1067
    if (s->pos >= s->check_point)
1081
1068
    {
1082
1069
      s->aio_inited= 0;