← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_open.cc

  • Committer: Tim Penhey
  • Date: 2010-01-20 02:39:01 UTC
  • mto: This revision was merged to the branch mainline in revision 1275.
  • Revision ID: tim.penhey@canonical.com-20100120023901-8teeunid6gwlthzx
Add in a rot 13 function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_open.cc
29
29
 
30
30
 
31
31
using namespace std;
32
 
using namespace drizzled;
33
32
 
34
33
static void setup_key_functions(MI_KEYDEF *keyinfo);
35
34
static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef);
88
87
  MI_INFO info,*m_info,*old_info;
89
88
  MYISAM_SHARE share_buff,*share;
90
89
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
91
 
  internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
 
90
  my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
92
91
  uint64_t max_key_file_length, max_data_file_length;
93
92
 
94
93
  kfile= -1;
97
96
  head_length=sizeof(share_buff.state.header);
98
97
  memset(&info, 0, sizeof(info));
99
98
 
100
 
  (void)internal::fn_format(org_name,name,"",MI_NAME_IEXT, MY_UNPACK_FILENAME);
 
99
  (void)fn_format(org_name,name,"",MI_NAME_IEXT, MY_UNPACK_FILENAME);
101
100
  if (!realpath(org_name,rp_buff))
102
 
    internal::my_load_path(rp_buff,org_name, NULL);
 
101
    my_load_path(rp_buff,org_name, NULL);
103
102
  rp_buff[FN_REFLEN-1]= '\0';
104
103
  strcpy(name_buff,rp_buff);
105
104
  pthread_mutex_lock(&THR_LOCK_myisam);
112
111
    share_buff.state.key_del=key_del;
113
112
    share_buff.key_cache= dflt_key_cache;
114
113
 
115
 
    if ((kfile=internal::my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
 
114
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
116
115
    {
117
116
      if ((errno != EROFS && errno != EACCES) ||
118
117
          mode != O_RDONLY ||
119
 
          (kfile=internal::my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
 
118
          (kfile=my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
120
119
        goto err;
121
120
    }
122
121
    share->mode=open_mode;
123
122
    errpos=1;
124
 
    if (internal::my_read(kfile, share->state.header.file_version, head_length,
 
123
    if (my_read(kfile, share->state.header.file_version, head_length,
125
124
                MYF(MY_NABP)))
126
125
    {
127
126
      errno= HA_ERR_NOT_A_TABLE;
151
150
    if (!strcmp(name_buff, org_name) || sym_link_size == -1)
152
151
      (void) strcpy(index_name, org_name);
153
152
    *strrchr(org_name, '.')= '\0';
154
 
    (void) internal::fn_format(data_name,org_name,"",MI_NAME_DEXT,
 
153
    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,
155
154
                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
156
155
 
157
156
    info_length=mi_uint2korr(share->state.header.header_length);
166
165
 
167
166
    lseek(kfile,0,SEEK_SET);
168
167
    errpos=3;
169
 
    if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
 
168
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
170
169
    {
171
170
      errno=HA_ERR_CRASHED;
172
171
      goto err;
223
222
      errno=HA_ERR_UNSUPPORTED;
224
223
      goto err;
225
224
    }
226
 
    share->base.max_data_file_length=(internal::my_off_t) max_data_file_length;
227
 
    share->base.max_key_file_length=(internal::my_off_t) max_key_file_length;
 
225
    share->base.max_data_file_length=(my_off_t) max_data_file_length;
 
226
    share->base.max_key_file_length=(my_off_t) max_key_file_length;
228
227
 
229
228
    if (share->options & HA_OPTION_COMPRESS_RECORD)
230
229
      share->base.max_key_length+=2;    /* For safety */
256
255
    memcpy(share->state.rec_per_key_part, rec_per_key_part,
257
256
           sizeof(long)*key_parts);
258
257
    memcpy(share->state.key_root, key_root,
259
 
           sizeof(internal::my_off_t)*keys);
 
258
           sizeof(my_off_t)*keys);
260
259
    memcpy(share->state.key_del, key_del,
261
 
           sizeof(internal::my_off_t) * share->state.header.max_block_size_index);
 
260
           sizeof(my_off_t) * share->state.header.max_block_size_index);
262
261
    strcpy(share->unique_file_name, name_buff);
263
262
    share->unique_name_length= strlen(name_buff);
264
263
    strcpy(share->index_file_name,  index_name);
527
526
    free((unsigned char*) m_info);
528
527
    /* fall through */
529
528
  case 5:
530
 
    internal::my_close(info.dfile,MYF(0));
 
529
    my_close(info.dfile,MYF(0));
531
530
    if (old_info)
532
531
      break;                                    /* Don't remove open table */
533
532
    /* fall through */
537
536
  case 3:
538
537
    /* fall through */
539
538
  case 1:
540
 
    internal::my_close(kfile,MYF(0));
 
539
    my_close(kfile,MYF(0));
541
540
    /* fall through */
542
541
  case 0:
543
542
  default:
589
588
 
590
589
static uint64_t mi_safe_mul(uint64_t a, uint64_t b)
591
590
{
592
 
  uint64_t max_val= ~ (uint64_t) 0;             /* internal::my_off_t is unsigned */
 
591
  uint64_t max_val= ~ (uint64_t) 0;             /* my_off_t is unsigned */
593
592
 
594
593
  if (!a || max_val / a < b)
595
594
    return max_val;
754
753
  if (pWrite & 1)
755
754
    return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
756
755
                          MYF(MY_NABP | MY_THREADSAFE)) != 0);
757
 
  return(internal::my_write(file, buff, (size_t) (ptr-buff),
 
756
  return(my_write(file, buff, (size_t) (ptr-buff),
758
757
                       MYF(MY_NABP)) != 0);
759
758
}
760
759
 
780
779
  state->state.empty    = mi_sizekorr(ptr);     ptr +=8;
781
780
  state->state.key_empty= mi_sizekorr(ptr);     ptr +=8;
782
781
  state->auto_increment=mi_uint8korr(ptr);      ptr +=8;
783
 
  state->state.checksum=(internal::ha_checksum) mi_uint8korr(ptr);      ptr +=8;
 
782
  state->state.checksum=(ha_checksum) mi_uint8korr(ptr);        ptr +=8;
784
783
  state->process= mi_uint4korr(ptr);            ptr +=4;
785
784
  state->unique = mi_uint4korr(ptr);            ptr +=4;
786
785
  state->status = mi_uint4korr(ptr);            ptr +=4;
821
820
    if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
822
821
      return 1;
823
822
  }
824
 
  else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))
 
823
  else if (my_read(file, buff, state->state_length,MYF(MY_NABP)))
825
824
    return 1;
826
825
  mi_state_info_read(buff, state);
827
826
 
866
865
  mi_int4store(ptr,UINT32_C(0));                        ptr +=4;
867
866
 
868
867
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
869
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
868
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
870
869
}
871
870
 
872
871
 
920
919
  mi_int2store(ptr,keydef->keylength);          ptr +=2;
921
920
  mi_int2store(ptr,keydef->minlength);          ptr +=2;
922
921
  mi_int2store(ptr,keydef->maxlength);          ptr +=2;
923
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
922
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
924
923
}
925
924
 
926
925
static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
962
961
  mi_int4store(ptr, pos);
963
962
  ptr+=4;
964
963
 
965
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
964
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
966
965
}
967
966
 
968
967
 
1002
1001
  *ptr++=  (unsigned char) def->key;
1003
1002
  *ptr++ = (unsigned char) def->null_are_equal;
1004
1003
 
1005
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
1004
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1006
1005
}
1007
1006
 
1008
1007
static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
1026
1025
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1027
1026
  *ptr++ = recinfo->null_bit;
1028
1027
  mi_int2store(ptr,recinfo->null_pos);  ptr+= 2;
1029
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
1028
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1030
1029
}
1031
1030
 
1032
1031
static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
1050
1049
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup)
1051
1050
{
1052
1051
  (void)file_to_dup; 
1053
 
  info->dfile=internal::my_open(share->data_file_name, share->mode,
 
1052
  info->dfile=my_open(share->data_file_name, share->mode,
1054
1053
                      MYF(MY_WME));
1055
1054
  return info->dfile >= 0 ? 0 : 1;
1056
1055
}
1058
1057
 
1059
1058
int mi_open_keyfile(MYISAM_SHARE *share)
1060
1059
{
1061
 
  if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,
 
1060
  if ((share->kfile=my_open(share->unique_file_name, share->mode,
1062
1061
                            MYF(MY_WME))) < 0)
1063
1062
    return 1;
1064
1063
  return 0;