← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/log_event.cc

  • Committer: Brian Aker
  • Date: 2008-12-09 17:33:02 UTC
  • mfrom: (656.1.54 devel)
  • Revision ID: brian@tangent.org-20081209173302-aptngvc7efxnatnt
Merge from Monty.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/log_event.cc
1974
1974
    return; /* sanity check */
1975
1975
  number_of_event_types=
1976
1976
    event_len-(LOG_EVENT_MINIMAL_HEADER_LEN+ST_COMMON_HEADER_LEN_OFFSET+1);
 
1977
  post_header_len= (uint8_t*) malloc(number_of_event_types*
 
1978
                                     sizeof(*post_header_len));
1977
1979
  /* If alloc fails, we'll detect it in is_valid() */
1978
 
  post_header_len= (uint8_t*) my_memdup((unsigned char*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
1979
 
                                      number_of_event_types*
1980
 
                                      sizeof(*post_header_len), MYF(0));
 
1980
  if (post_header_len != NULL)
 
1981
    memcpy(post_header_len, buf+ST_COMMON_HEADER_LEN_OFFSET+1,
 
1982
           number_of_event_types* sizeof(*post_header_len));
1981
1983
  calc_server_version_split();
1982
1984
 
1983
1985
  /*
2861
2863
  char buf1[256], buf[22];
2862
2864
  String tmp(buf1, sizeof(buf1), &my_charset_utf8_general_ci);
2863
2865
  tmp.length(0);
2864
 
  tmp.append(new_log_ident, ident_len);
 
2866
  tmp.append(new_log_ident.c_str(), ident_len);
2865
2867
  tmp.append(STRING_WITH_LEN(";pos="));
2866
2868
  tmp.append(llstr(pos,buf));
2867
2869
  protocol->store(tmp.ptr(), tmp.length(), &my_charset_bin);
2876
2878
Rotate_log_event::Rotate_log_event(const char* new_log_ident_arg,
2877
2879
                                   uint32_t ident_len_arg, uint64_t pos_arg,
2878
2880
                                   uint32_t flags_arg)
2879
 
  :Log_event(), new_log_ident(new_log_ident_arg),
2880
 
   pos(pos_arg),ident_len(ident_len_arg ? ident_len_arg :
2881
 
                          (uint) strlen(new_log_ident_arg)), flags(flags_arg)
 
2881
  :Log_event(), pos(pos_arg),
 
2882
   ident_len(ident_len_arg
 
2883
               ? ident_len_arg
 
2884
               : strlen(new_log_ident_arg)),
 
2885
   flags(flags_arg)
2882
2886
{
2883
 
  if (flags & DUP_NAME)
2884
 
    new_log_ident= my_strndup(new_log_ident_arg, ident_len, MYF(MY_WME));
 
2887
  new_log_ident.assign(new_log_ident_arg, ident_len);
2885
2888
  return;
2886
2889
}
2887
2890
 
2888
2891
 
2889
2892
Rotate_log_event::Rotate_log_event(const char* buf, uint32_t event_len,
2890
2893
                                   const Format_description_log_event* description_event)
2891
 
  :Log_event(buf, description_event) ,new_log_ident(0), flags(DUP_NAME)
 
2894
  :Log_event(buf, description_event), flags(DUP_NAME)
2892
2895
{
2893
2896
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
2894
2897
  uint8_t header_size= description_event->common_header_len;
2902
2905
                     (header_size+post_header_len));
2903
2906
  ident_offset = post_header_len;
2904
2907
  set_if_smaller(ident_len,FN_REFLEN-1);
2905
 
  new_log_ident= my_strndup(buf + ident_offset, (uint) ident_len, MYF(MY_WME));
 
2908
  new_log_ident.assign(buf + ident_offset, ident_len);
2906
2909
  return;
2907
2910
}
2908
2911
 
2917
2920
  int8store(buf + R_POS_OFFSET, pos);
2918
2921
  return (write_header(file, ROTATE_HEADER_LEN + ident_len) ||
2919
2922
          my_b_safe_write(file, (unsigned char*)buf, ROTATE_HEADER_LEN) ||
2920
 
          my_b_safe_write(file, (unsigned char*)new_log_ident, (uint) ident_len));
 
2923
          my_b_safe_write(file, (const unsigned char*)new_log_ident.c_str(),
 
2924
                          (uint) ident_len));
2921
2925
}
2922
2926
 
2923
2927
 
2957
2961
  if ((server_id != ::server_id || rli->replicate_same_server_id) &&
2958
2962
      !rli->is_in_group())
2959
2963
  {
2960
 
    rli->group_master_log_name.assign(new_log_ident, ident_len+1);
 
2964
    rli->group_master_log_name.assign(new_log_ident);
2961
2965
    rli->notify_group_master_log_name_update();
2962
2966
    rli->group_master_log_pos= pos;
2963
2967
    rli->group_relay_log_name.assign(rli->event_relay_log_name);
3262
3266
  uint32_t header_len= description_event->common_header_len;
3263
3267
  uint8_t load_header_len= description_event->post_header_len[LOAD_EVENT-1];
3264
3268
  uint8_t create_file_header_len= description_event->post_header_len[CREATE_FILE_EVENT-1];
3265
 
  if (!(event_buf= (char*) my_memdup(buf, len, MYF(MY_WME))) ||
 
3269
  if (!(event_buf= (const char*)malloc(len)) ||
 
3270
      memcpy((char *)event_buf, buf, len) ||
3266
3271
      copy_log_event(event_buf,len,
3267
3272
                     ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
3268
3273
                      load_header_len + header_len :
3708
3713
      don't want to overwrite it with the filename.
3709
3714
      What we want instead is add the filename to the current error message.
3710
3715
    */
3711
 
    char *tmp= my_strdup(rli->last_error().message, MYF(MY_WME));
 
3716
    char *tmp= strdup(rli->last_error().message);
3712
3717
    if (tmp)
3713
3718
    {
3714
3719
      rli->report(ERROR_LEVEL, rli->last_error().number,
4197
4202
  if (static_cast<size_t>(m_rows_end - m_rows_cur) <= length)
4198
4203
  {
4199
4204
    size_t const block_size= 1024;
4200
 
    my_ptrdiff_t const cur_size= m_rows_cur - m_rows_buf;
4201
 
    my_ptrdiff_t const new_alloc=
 
4205
    const size_t cur_size= m_rows_cur - m_rows_buf;
 
4206
    const size_t new_alloc=
4202
4207
        block_size * ((cur_size + length + block_size - 1) / block_size);
4203
4208
 
4204
 
    unsigned char* const new_buf= (unsigned char*)my_realloc((unsigned char*)m_rows_buf, (uint) new_alloc,
4205
 
                                           MYF(MY_ALLOW_ZERO_PTR|MY_WME));
 
4209
    unsigned char* new_buf= (unsigned char*)realloc(m_rows_buf, new_alloc);
4206
4210
    if (unlikely(!new_buf))
4207
4211
      return(HA_ERR_OUT_OF_MEM);
4208
4212