← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/archive/azio.c

  • Committer: Monty Taylor
  • Date: 2008-10-22 01:52:54 UTC
  • Revision ID: monty@inaugust.com-20081022015254-65qfk9f2v0b8jlk3
Moved drizzle_com to drizzled/drizzle_common. Started splitting it up.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/archive/azio.c
20
20
 
21
21
static int const az_magic[3] = {0xfe, 0x03, 0x01}; /* az magic header */
22
22
 
23
 
/* gzip flag unsigned char */
24
 
#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
25
 
#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
26
 
#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
27
 
#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
28
 
#define COMMENT      0x10 /* bit 4 set: file comment present */
29
 
#define RESERVED     0xE0 /* bits 5..7: reserved */
30
 
 
31
23
static unsigned int azwrite(azio_stream *s, void *buf, unsigned int len);
32
24
static int azrewind (azio_stream *s);
33
25
static unsigned int azio_enable_aio(azio_stream *s);
34
26
static int do_flush(azio_stream *file, int flush);
35
27
static int    get_byte(azio_stream *s);
36
28
static void   check_header(azio_stream *s);
37
 
static void write_header(azio_stream *s);
 
29
static int write_header(azio_stream *s);
38
30
static int    destroy(azio_stream *s);
39
31
static void putLong(azio_stream *s, uLong x);
40
32
static uLong  getLong(azio_stream *s);
253
245
    s->frm_length= 0;
254
246
    s->dirty= 1; /* We create the file dirty */
255
247
    s->start = AZHEADER_SIZE + AZMETA_BUFFER_SIZE;
256
 
    write_header(s);
 
248
    if(write_header(s))
 
249
      return Z_NULL;
257
250
    s->pos= (size_t)my_seek(s->file, 0, MY_SEEK_END, MYF(0));
258
251
  }
259
252
  else if (s->mode == 'w') 
260
253
  {
261
254
    unsigned char buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];
262
 
    pread(s->file, buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0);
 
255
    const ssize_t read_size= AZHEADER_SIZE + AZMETA_BUFFER_SIZE;
 
256
    if(pread(s->file, buffer, read_size, 0) < read_size)
 
257
      return Z_NULL;
263
258
    read_header(s, buffer);
264
259
    s->pos= (size_t)my_seek(s->file, 0, MY_SEEK_END, MYF(0));
265
260
  }
282
277
}
283
278
 
284
279
 
285
 
void write_header(azio_stream *s)
 
280
int write_header(azio_stream *s)
286
281
{
287
282
  char buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];
288
283
  char *ptr= buffer;
306
301
  int4store(ptr + AZ_COMMENT_LENGTH_POS, s->comment_length); /* COMMENT Block */
307
302
  int4store(ptr + AZ_META_POS, 0); /* Meta Block */
308
303
  int4store(ptr + AZ_META_LENGTH_POS, 0); /* Meta Block */
309
 
  int8store(ptr + AZ_START_POS, (unsigned long long)s->start); /* Start of Data Block Index Block */
310
 
  int8store(ptr + AZ_ROW_POS, (unsigned long long)s->rows); /* Start of Data Block Index Block */
311
 
  int8store(ptr + AZ_FLUSH_POS, (unsigned long long)s->forced_flushes); /* Start of Data Block Index Block */
312
 
  int8store(ptr + AZ_CHECK_POS, (unsigned long long)s->check_point); /* Start of Data Block Index Block */
313
 
  int8store(ptr + AZ_AUTOINCREMENT_POS, (unsigned long long)s->auto_increment); /* Start of Data Block Index Block */
 
304
  int8store(ptr + AZ_START_POS, (uint64_t)s->start); /* Start of Data Block Index Block */
 
305
  int8store(ptr + AZ_ROW_POS, (uint64_t)s->rows); /* Start of Data Block Index Block */
 
306
  int8store(ptr + AZ_FLUSH_POS, (uint64_t)s->forced_flushes); /* Start of Data Block Index Block */
 
307
  int8store(ptr + AZ_CHECK_POS, (uint64_t)s->check_point); /* Start of Data Block Index Block */
 
308
  int8store(ptr + AZ_AUTOINCREMENT_POS, (uint64_t)s->auto_increment); /* Start of Data Block Index Block */
314
309
  int4store(ptr+ AZ_LONGEST_POS , s->longest_row); /* Longest row */
315
310
  int4store(ptr+ AZ_SHORTEST_POS, s->shortest_row); /* Shorest row */
316
311
  int4store(ptr+ AZ_FRM_POS, 
318
313
  *(ptr + AZ_DIRTY_POS)= (unsigned char)s->dirty; /* Start of Data Block Index Block */
319
314
 
320
315
  /* Always begin at the begining, and end there as well */
321
 
  pwrite(s->file, (unsigned char*) buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0);
 
316
  const ssize_t write_size= AZHEADER_SIZE + AZMETA_BUFFER_SIZE;
 
317
  if(pwrite(s->file, (unsigned char*) buffer, write_size, 0)!=write_size)
 
318
    return -1;
 
319
 
 
320
  return 0;
322
321
}
323
322
 
324
323
/* ===========================================================================
402
401
    s->minor_version= (unsigned int)buffer[AZ_MINOR_VERSION_POS];
403
402
    s->block_size= 1024 * buffer[AZ_BLOCK_POS];
404
403
    s->start= (size_t)uint8korr(buffer + AZ_START_POS);
405
 
    s->rows= (unsigned long long)uint8korr(buffer + AZ_ROW_POS);
406
 
    s->check_point= (unsigned long long)uint8korr(buffer + AZ_CHECK_POS);
407
 
    s->forced_flushes= (unsigned long long)uint8korr(buffer + AZ_FLUSH_POS);
408
 
    s->auto_increment= (unsigned long long)uint8korr(buffer + AZ_AUTOINCREMENT_POS);
 
404
    s->rows= (uint64_t)uint8korr(buffer + AZ_ROW_POS);
 
405
    s->check_point= (uint64_t)uint8korr(buffer + AZ_CHECK_POS);
 
406
    s->forced_flushes= (uint64_t)uint8korr(buffer + AZ_FLUSH_POS);
 
407
    s->auto_increment= (uint64_t)uint8korr(buffer + AZ_AUTOINCREMENT_POS);
409
408
    s->longest_row= (unsigned int)uint4korr(buffer + AZ_LONGEST_POS);
410
409
    s->shortest_row= (unsigned int)uint4korr(buffer + AZ_SHORTEST_POS);
411
410
    s->frm_start_pos= (unsigned int)uint4korr(buffer + AZ_FRM_POS);
697
696
    s->dirty= AZ_STATE_SAVED; /* Mark it clean, we should be good now */
698
697
 
699
698
  afterwrite_pos= (size_t)my_tell(s->file, MYF(0));
700
 
  write_header(s);
 
699
  if(write_header(s))
 
700
    return Z_ERRNO;
701
701
 
702
702
  return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
703
703
}
730
730
  if (s->mode == 'r') 
731
731
  {
732
732
    unsigned char buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];
733
 
    pread(s->file, (unsigned char*) buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0);
 
733
    const ssize_t read_size= AZHEADER_SIZE + AZMETA_BUFFER_SIZE;
 
734
    if(pread(s->file, (unsigned char*) buffer, read_size, 0)!=read_size)
 
735
      return Z_ERRNO;
734
736
    read_header(s, buffer); /* skip the .az header */
735
737
    azrewind(s);
736
738
 
893
895
  for (n = 0; n < 4; n++) 
894
896
  {
895
897
    buffer[0]= (int)(x & 0xff);
896
 
    pwrite(s->file, buffer, 1, s->pos);
 
898
    assert(pwrite(s->file, buffer, 1, s->pos)==1);
897
899
    s->pos++;
898
900
    x >>= 8;
899
901
  }
974
976
  s->frm_length= length;
975
977
  s->start+= length;
976
978
 
977
 
  pwrite(s->file, (unsigned char*) blob, s->frm_length, s->frm_start_pos);
 
979
  if (pwrite(s->file, (unsigned char*) blob, s->frm_length, s->frm_start_pos) != (ssize_t)s->frm_length)
 
980
    return 1;
978
981
 
979
982
  write_header(s);
980
983
  s->pos= (size_t)my_seek(s->file, 0, MY_SEEK_END, MYF(0));
984
987
 
985
988
int azread_frm(azio_stream *s, char *blob)
986
989
{
987
 
  pread(s->file, (unsigned char*) blob, s->frm_length, s->frm_start_pos);
 
990
  ssize_t r= pread(s->file, (unsigned char*) blob,
 
991
                   s->frm_length, s->frm_start_pos);
 
992
  if (r != (ssize_t)s->frm_length)
 
993
    return r;
988
994
 
989
995
  return 0;
990
996
}
1005
1011
  s->comment_length= length;
1006
1012
  s->start+= length;
1007
1013
 
1008
 
  pwrite(s->file, (unsigned char*) blob, s->comment_length, s->comment_start_pos);
 
1014
  ssize_t r= pwrite(s->file, (unsigned char*) blob,
 
1015
                    s->comment_length, s->comment_start_pos);
 
1016
  if (r != (ssize_t)s->comment_length)
 
1017
    return r;
1009
1018
 
1010
1019
  write_header(s);
1011
1020
  s->pos= (size_t)my_seek(s->file, 0, MY_SEEK_END, MYF(0));
1015
1024
 
1016
1025
int azread_comment(azio_stream *s, char *blob)
1017
1026
{
1018
 
  pread(s->file, (unsigned char*) blob, s->comment_length, s->comment_start_pos);
 
1027
  ssize_t r= pread(s->file, (unsigned char*) blob,
 
1028
                   s->comment_length, s->comment_start_pos);
 
1029
  if (r != (ssize_t)s->comment_length)
 
1030
    return r;
1019
1031
 
1020
1032
  return 0;
1021
1033
}