开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
log.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：25k
源码类别：

MySQL数据库

开发平台：

Visual C++

log.cc：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* logging of commands */
  19. /* TODO: Abort logging when we get an error in reading or writing log files */
  21. #ifdef __EMX__
  22. #include <io.h>
  23. #endif
  25. #include "mysql_priv.h"
  26. #include "sql_acl.h"
  27. #include "sql_repl.h"
  29. #include <my_dir.h>
  30. #include <stdarg.h>
  31. #include <m_ctype.h> // For test_if_number
  33. MYSQL_LOG mysql_log,mysql_update_log,mysql_slow_log,mysql_bin_log;
  34. extern I_List<i_string> binlog_do_db, binlog_ignore_db;
  35. extern ulong max_binlog_size;
  37. static bool test_if_number(const char *str,
  38.    long *res, bool allow_wildcards);
  40. /****************************************************************************
  41. ** Find a uniq filename for 'filename.#'.
  42. ** Set # to a number as low as possible
  43. ** returns != 0 if not possible to get uniq filename
  44. ****************************************************************************/
  46. static int find_uniq_filename(char *name)
  47. {
  48.   long number;
  49.   uint i,length;
  50.   char buff[FN_REFLEN];
  51.   struct st_my_dir *dir_info;
  52.   reg1 struct fileinfo *file_info;
  53.   ulong max_found=0;
  54.   DBUG_ENTER("find_uniq_filename");
  56.   length=dirname_part(buff,name);
  57.   char *start=name+length,*end=strend(start);
  58.   *end='.';
  59.   length= (uint) (end-start+1);
  61.   if (!(dir_info = my_dir(buff,MYF(MY_DONT_SORT))))
  62.   { // This shouldn't happen
  63.     strmov(end,".1"); // use name+1
  64.     DBUG_RETURN(0);
  65.   }
  66.   file_info= dir_info->dir_entry;
  67.   for (i=dir_info->number_off_files ; i-- ; file_info++)
  68.   {
  69.     if (bcmp(file_info->name,start,length) == 0 &&
  70. test_if_number(file_info->name+length, &number,0))
  71.     {
  72.       set_if_bigger(max_found,(ulong) number);
  73.     }
  74.   }
  75.   my_dirend(dir_info);
  77.   *end++='.';
  78.   sprintf(end,"%03ld",max_found+1);
  79.   DBUG_RETURN(0);
  80. }
  82. MYSQL_LOG::MYSQL_LOG(): last_time(0), query_start(0),index_file(-1),
  83. name(0), log_type(LOG_CLOSED),write_error(0),
  84. inited(0), no_rotate(0)
  85. {
  86.   /*
  87.     We don't want to intialize LOCK_Log here as the thread system may
  88.     not have been initailized yet. We do it instead at 'open'.
  89.   */
  90.   index_file_name[0] = 0;
  91.   bzero((char*) &log_file,sizeof(log_file));
  92. }
  94. MYSQL_LOG::~MYSQL_LOG()
  95. {
  96.   if (inited)
  97.   {
  98.     (void) pthread_mutex_destroy(&LOCK_log);
  99.     (void) pthread_mutex_destroy(&LOCK_index);
  100.   }
  101. }
  103. void MYSQL_LOG::set_index_file_name(const char* index_file_name)
  104. {
  105.   if (index_file_name)
  106.     fn_format(this->index_file_name,index_file_name,mysql_data_home,"-index",
  107.       4);
  108.   else
  109.     this->index_file_name[0] = 0;
  110. }
  113. int MYSQL_LOG::generate_new_name(char *new_name, const char *log_name)
  114. {      
  115.   if (log_type == LOG_NORMAL)
  116.     fn_format(new_name,log_name,mysql_data_home,"",4);
  117.   else
  118.   {
  119.     fn_format(new_name,log_name,mysql_data_home,"",4);
  120.     if (!fn_ext(log_name)[0])
  121.     {
  122.       if (find_uniq_filename(new_name))
  123.       {
  124. sql_print_error(ER(ER_NO_UNIQUE_LOGFILE), log_name);
  125. return 1;
  126.       }
  127.     }
  128.   }
  129.   return 0;
  130. }
  133. void MYSQL_LOG::open(const char *log_name, enum_log_type log_type_arg,
  134.      const char *new_name)
  135. {
  136.   MY_STAT tmp_stat;
  137.   char buff[512];
  138.   File file= -1;
  139.   bool do_magic;
  141.   if (!inited)
  142.   {
  143.     inited=1;
  144.     (void) pthread_mutex_init(&LOCK_log,NULL);
  145.     (void) pthread_mutex_init(&LOCK_index, NULL);
  146.     if (log_type_arg == LOG_BIN && *fn_ext(log_name))
  147.       no_rotate = 1;
  148.   }
  149.   
  150.   log_type=log_type_arg;
  151.   if (!(name=my_strdup(log_name,MYF(MY_WME))))
  152.     goto err;
  153.   if (new_name)
  154.     strmov(log_file_name,new_name);
  155.   else if (generate_new_name(log_file_name, name))
  156.     goto err;
  158.   if (log_type == LOG_BIN && !index_file_name[0])
  159.     fn_format(index_file_name, name, mysql_data_home, ".index", 6);
  160.   
  161.   db[0]=0;
  162.   do_magic = ((log_type == LOG_BIN) && !my_stat(log_file_name,
  163. &tmp_stat, MYF(0)));
  164.   
  165.   if ((file=my_open(log_file_name,O_CREAT | O_APPEND | O_WRONLY | O_BINARY,
  166.     MYF(MY_WME | ME_WAITTANG))) < 0 ||
  167.       init_io_cache(&log_file, file, IO_SIZE, WRITE_CACHE,
  168.     my_tell(file,MYF(MY_WME)), 0, MYF(MY_WME | MY_NABP)))
  169.     goto err;
  171.   if (log_type == LOG_NORMAL)
  172.   {
  173.     char *end;
  174. #ifdef __NT__
  175.     sprintf(buff, "%s, Version: %s, started with:nTCP Port: %d, Named Pipe: %sn", my_progname, server_version, mysql_port, mysql_unix_port);
  176. #else
  177.     sprintf(buff, "%s, Version: %s, started with:nTcp port: %d  Unix socket: %sn", my_progname,server_version,mysql_port,mysql_unix_port);
  178. #endif
  179.     end=strmov(strend(buff),"Time                 Id Command    Argumentn");
  180.     if (my_b_write(&log_file, (byte*) buff,(uint) (end-buff)) ||
  181. flush_io_cache(&log_file))
  182.       goto err;
  183.   }
  184.   else if (log_type == LOG_NEW)
  185.   {
  186.     time_t skr=time(NULL);
  187.     struct tm tm_tmp;
  188.     localtime_r(&skr,&tm_tmp);
  189.     sprintf(buff,"# %s, Version: %s at %02d%02d%02d %2d:%02d:%02dn",
  190.     my_progname,server_version,
  191.     tm_tmp.tm_year % 100,
  192.     tm_tmp.tm_mon+1,
  193.     tm_tmp.tm_mday,
  194.     tm_tmp.tm_hour,
  195.     tm_tmp.tm_min,
  196.     tm_tmp.tm_sec);
  197.     if (my_b_write(&log_file, (byte*) buff,(uint) strlen(buff)) ||
  198. flush_io_cache(&log_file))
  199.       goto err;
  200.   }
  201.   else if (log_type == LOG_BIN)
  202.   {
  203.     /*
  204.       Explanation of the boolean black magic:
  205.       if we are supposed to write magic number try write
  206.       clean up if failed
  207.       then if index_file has not been previously opened, try to open it
  208.       clean up if failed
  209.     */
  210.     if ((do_magic && my_b_write(&log_file, (byte*) BINLOG_MAGIC, 4)) ||
  211. (index_file < 0 && 
  212.  (index_file = my_open(index_file_name,
  213.        O_APPEND | O_BINARY | O_RDWR | O_CREAT,
  214.        MYF(MY_WME))) < 0))
  215.       goto err;
  216.     Start_log_event s;
  217.     bool error;
  218.     s.write(&log_file);
  219.     flush_io_cache(&log_file);
  220.     pthread_mutex_lock(&LOCK_index);
  221.     error=(my_write(index_file, (byte*) log_file_name, strlen(log_file_name),
  222.     MYF(MY_NABP | MY_WME)) ||
  223.    my_write(index_file, (byte*) "n", 1, MYF(MY_NABP | MY_WME)));
  224.     pthread_mutex_unlock(&LOCK_index);
  225.     if (error)
  226.     {
  227.       my_close(index_file,MYF(0));
  228.       index_file= -1;
  229.       goto err;
  230.     }
  231.   }
  232.   return;
  234. err:
  235.   sql_print_error("Could not use %s for logging (error %d)", log_name,errno);
  236.   if (file >= 0)
  237.     my_close(file,MYF(0));
  238.   end_io_cache(&log_file);
  239.   x_free(name); name=0;
  240.   log_type=LOG_CLOSED;
  242.   return;
  243.   
  244. }
  246. int MYSQL_LOG::get_current_log(LOG_INFO* linfo)
  247. {
  248.   pthread_mutex_lock(&LOCK_log);
  249.   strmake(linfo->log_file_name, log_file_name, sizeof(linfo->log_file_name)-1);
  250.   linfo->pos = my_b_tell(&log_file);
  251.   pthread_mutex_unlock(&LOCK_log);
  252.   return 0;
  253. }
  255. // if log_name is "" we stop at the first entry
  256. int MYSQL_LOG::find_first_log(LOG_INFO* linfo, const char* log_name)
  257. {
  258.   if (index_file < 0)
  259.     return LOG_INFO_INVALID;
  260.   int error = 0;
  261.   char* fname = linfo->log_file_name;
  262.   uint log_name_len = (uint) strlen(log_name);
  263.   IO_CACHE io_cache;
  265.   // mutex needed because we need to make sure the file pointer does not move
  266.   // from under our feet
  267.   pthread_mutex_lock(&LOCK_index);
  268.   if (init_io_cache(&io_cache, index_file, IO_SIZE, READ_CACHE, (my_off_t) 0,
  269.     0, MYF(MY_WME)))
  270.   {
  271.     error = LOG_INFO_SEEK;
  272.     goto err;
  273.   }
  274.   for(;;)
  275.   {
  276.     uint length;
  277.     if (!(length=my_b_gets(&io_cache, fname, FN_REFLEN-1)))
  278.     {
  279.       error = !io_cache.error ? LOG_INFO_EOF : LOG_INFO_IO;
  280.       goto err;
  281.     }
  283.     // if the log entry matches, empty string matching anything
  284.     if (!log_name_len ||
  285. (log_name_len == length-1 && fname[log_name_len] == 'n' &&
  286.  !memcmp(fname, log_name, log_name_len)))
  287.     {
  288.       fname[length-1]=0; // remove last n
  289.       linfo->index_file_offset = my_b_tell(&io_cache);
  290.       break;
  291.     }
  292.   }
  293.   error = 0;
  295. err:
  296.   pthread_mutex_unlock(&LOCK_index);
  297.   end_io_cache(&io_cache);
  298.   return error;
  299.      
  300. }
  303. int MYSQL_LOG::find_next_log(LOG_INFO* linfo)
  304. {
  305.   // mutex needed because we need to make sure the file pointer does not move
  306.   // from under our feet
  307.   if (index_file < 0) return LOG_INFO_INVALID;
  308.   int error = 0;
  309.   char* fname = linfo->log_file_name;
  310.   IO_CACHE io_cache;
  311.   uint length;
  313.   pthread_mutex_lock(&LOCK_index);
  314.   if (init_io_cache(&io_cache, index_file, IO_SIZE, 
  315.     READ_CACHE, (my_off_t) linfo->index_file_offset, 0,
  316.     MYF(MY_WME)))
  317.   {
  318.     error = LOG_INFO_SEEK;
  319.     goto err;
  320.   }
  321.   if (!(length=my_b_gets(&io_cache, fname, FN_REFLEN)))
  322.   {
  323.     error = !io_cache.error ? LOG_INFO_EOF : LOG_INFO_IO;
  324.     goto err;
  325.   }
  326.   fname[length-1]=0; // kill /n
  327.   linfo->index_file_offset = my_b_tell(&io_cache);
  328.   error = 0;
  330. err:
  331.   pthread_mutex_unlock(&LOCK_index);
  332.   end_io_cache(&io_cache);
  333.   return error;
  334. }
  336.  
  337. int MYSQL_LOG::purge_logs(THD* thd, const char* to_log)
  338. {
  339.   if (index_file < 0) return LOG_INFO_INVALID;
  340.   if (no_rotate) return LOG_INFO_PURGE_NO_ROTATE;
  341.   int error;
  342.   char fname[FN_REFLEN];
  343.   char *p;
  344.   uint fname_len, i;
  345.   bool logs_to_purge_inited = 0, logs_to_keep_inited = 0, found_log = 0;
  346.   DYNAMIC_ARRAY logs_to_purge, logs_to_keep;
  347.   my_off_t purge_offset ;
  348.   LINT_INIT(purge_offset);
  349.   IO_CACHE io_cache;
  350.   
  351.   pthread_mutex_lock(&LOCK_index);
  352.   
  353.   if (init_io_cache(&io_cache,index_file, IO_SIZE*2, READ_CACHE, (my_off_t) 0,
  354.     0, MYF(MY_WME)))
  355.   {
  356.     error = LOG_INFO_MEM;
  357.     goto err;
  358.   }
  359.   if (init_dynamic_array(&logs_to_purge, sizeof(char*), 1024, 1024))
  360.   {
  361.     error = LOG_INFO_MEM;
  362.     goto err;
  363.   }
  364.   logs_to_purge_inited = 1;
  365.   
  366.   if (init_dynamic_array(&logs_to_keep, sizeof(char*), 1024, 1024))
  367.   {
  368.     error = LOG_INFO_MEM;
  369.     goto err;
  370.   }
  371.   logs_to_keep_inited = 1;
  373.   
  374.   for(;;)
  375.   {
  376.     my_off_t init_purge_offset= my_b_tell(&io_cache);
  377.     if (!(fname_len=my_b_gets(&io_cache, fname, FN_REFLEN)))
  378.     {
  379.       if(!io_cache.error)
  380. break;
  381.       error = LOG_INFO_IO;
  382.       goto err;
  383.     }
  385.     fname[--fname_len]=0; // kill n
  386.     if(!memcmp(fname, to_log, fname_len + 1 ))
  387.     {
  388.       found_log = 1;
  389.       purge_offset = init_purge_offset;
  390.     }
  391.       
  392.     // if one of the logs before the target is in use
  393.     if(!found_log && log_in_use(fname))
  394.     {
  395.       error = LOG_INFO_IN_USE;
  396.       goto err;
  397.     }
  398.       
  399.     if (!(p = sql_memdup(fname, fname_len+1)) ||
  400. insert_dynamic(found_log ? &logs_to_keep : &logs_to_purge,
  401.        (gptr) &p))
  402.     {
  403.       error = LOG_INFO_MEM;
  404.       goto err;
  405.     }
  406.   }
  407.   
  408.   end_io_cache(&io_cache);
  409.   if(!found_log)
  410.   {
  411.     error = LOG_INFO_EOF;
  412.     goto err;
  413.   }
  414.   
  415.   for(i = 0; i < logs_to_purge.elements; i++)
  416.   {
  417.     char* l;
  418.     get_dynamic(&logs_to_purge, (gptr)&l, i);
  419.     if (my_delete(l, MYF(MY_WME)))
  420.       sql_print_error("Error deleting %s during purge", l);
  421.   }
  422.   
  423.   // if we get killed -9 here, the sysadmin would have to do a small
  424.   // vi job on the log index file after restart - otherwise, this should
  425.   // be safe
  426. #ifdef HAVE_FTRUNCATE
  427.   if (ftruncate(index_file,0))
  428.   {
  429.     sql_print_error("Could not truncate the binlog index file 
  430. during log purge for write");
  431.     error = LOG_INFO_FATAL;
  432.     goto err;
  433.   }
  434.   my_seek(index_file, 0, MY_SEEK_CUR,MYF(MY_WME));
  435. #else
  436.   my_close(index_file, MYF(MY_WME));
  437.   my_delete(index_file_name, MYF(MY_WME));
  438.   if(!(index_file = my_open(index_file_name,
  439.     O_CREAT | O_BINARY | O_RDWR | O_APPEND,
  440.     MYF(MY_WME))))
  441.   {
  442.     sql_print_error("Could not re-open the binlog index file 
  443. during log purge for write");
  444.     error = LOG_INFO_FATAL;
  445.     goto err;
  446.   }
  447. #endif
  448.   
  449.   for(i = 0; i < logs_to_keep.elements; i++)
  450.   {
  451.     char* l;
  452.     get_dynamic(&logs_to_keep, (gptr)&l, i);
  453.     if (my_write(index_file, (byte*) l, strlen(l), MYF(MY_WME|MY_NABP)) ||
  454. my_write(index_file, (byte*) "n", 1, MYF(MY_WME|MY_NABP)))
  455.     {
  456.       error = LOG_INFO_FATAL;
  457.       goto err;
  458.     }
  459.   }
  461.   // now update offsets
  462.   adjust_linfo_offsets(purge_offset);
  463.   error = 0;
  465. err:
  466.   pthread_mutex_unlock(&LOCK_index);
  467.   if(logs_to_purge_inited)
  468.     delete_dynamic(&logs_to_purge);
  469.   if(logs_to_keep_inited)
  470.     delete_dynamic(&logs_to_keep);
  471.   end_io_cache(&io_cache);
  472.   return error;
  473. }
  476. // we assume that buf has at least FN_REFLEN bytes alloced
  477. void MYSQL_LOG::make_log_name(char* buf, const char* log_ident)
  478. {
  479.   buf[0] = 0; // In case of error
  480.   if (inited)
  481.   {
  482.     int dir_len = dirname_length(log_file_name); 
  483.     int ident_len = (uint) strlen(log_ident);
  484.     if (dir_len + ident_len + 1 > FN_REFLEN)
  485.       return; // protection agains malicious buffer overflow
  486.       
  487.     memcpy(buf, log_file_name, dir_len);
  488.     // copy filename + end null
  489.     memcpy(buf + dir_len, log_ident, ident_len + 1);
  490.   }
  491. }
  493. bool MYSQL_LOG::is_active(const char* log_file_name)
  494. {
  495.   return inited && !strcmp(log_file_name, this->log_file_name);
  496. }
  498. void MYSQL_LOG::new_file()
  499. {
  500.   // only rotate open logs that are marked non-rotatable
  501.   // (binlog with constant name are non-rotatable)
  502.   if (is_open() && ! no_rotate)
  503.   {
  504.     char new_name[FN_REFLEN], *old_name=name;
  505.     VOID(pthread_mutex_lock(&LOCK_log));
  506.     if (generate_new_name(new_name, name))
  507.     {
  508.       VOID(pthread_mutex_unlock(&LOCK_log));
  509.       return; // Something went wrong
  510.     }
  511.     if (log_type == LOG_BIN)
  512.     {
  513.       /*
  514. We log the whole file name for log file as the user may decide
  515. to change base names at some point.
  516.       */
  517.       Rotate_log_event r(new_name+dirname_length(new_name));
  518.       r.write(&log_file);
  519.       VOID(pthread_cond_broadcast(&COND_binlog_update));
  520.     }
  521.     name=0;
  522.     close();
  523.     open(old_name, log_type, new_name);
  524.     my_free(old_name,MYF(0));
  525.     last_time=query_start=0;
  526.     write_error=0;
  527.     VOID(pthread_mutex_unlock(&LOCK_log));
  528.   }
  529. }
  532. bool MYSQL_LOG::write(THD *thd,enum enum_server_command command,
  533.       const char *format,...)
  534. {
  535.   if (is_open() && (what_to_log & (1L << (uint) command)))
  536.   {
  537.     int error=0;
  538.     VOID(pthread_mutex_lock(&LOCK_log));
  540.     /* Test if someone closed after the is_open test */
  541.     if (log_type != LOG_CLOSED)
  542.     {
  543.       time_t skr;
  544.       ulong id;
  545.       va_list args;
  546.       va_start(args,format);
  547.       char buff[32];
  549.       if (thd)
  550.       { // Normal thread
  551. if ((thd->options & OPTION_LOG_OFF) &&
  552.     (thd->master_access & PROCESS_ACL))
  553. {
  554.   VOID(pthread_mutex_unlock(&LOCK_log));
  555.   return 0; // No logging
  556. }
  557. id=thd->thread_id;
  558. if (thd->user_time || !(skr=thd->query_start()))
  559.   skr=time(NULL); // Connected
  560.       }
  561.       else
  562.       { // Log from connect handler
  563. skr=time(NULL);
  564. id=0;
  565.       }
  566.       if (skr != last_time)
  567.       {
  568. last_time=skr;
  569. struct tm tm_tmp;
  570. struct tm *start;
  571. localtime_r(&skr,&tm_tmp);
  572. start=&tm_tmp;
  573. /* Note that my_b_write() assumes it knows the length for this */
  574. sprintf(buff,"%02d%02d%02d %2d:%02d:%02dt",
  575. start->tm_year % 100,
  576. start->tm_mon+1,
  577. start->tm_mday,
  578. start->tm_hour,
  579. start->tm_min,
  580. start->tm_sec);
  581. if (my_b_write(&log_file, (byte*) buff,16))
  582.   error=errno;
  583.       }
  584.       else if (my_b_write(&log_file, (byte*) "tt",2) < 0)
  585. error=errno;
  586.       sprintf(buff,"%7ld %-11.11s", id,command_name[(uint) command]);
  587.       if (my_b_write(&log_file, (byte*) buff,strlen(buff)))
  588. error=errno;
  589.       if (format)
  590.       {
  591. if (my_b_write(&log_file, (byte*) " ",1) ||
  592.     my_b_vprintf(&log_file,format,args) == (uint) -1)
  593.   error=errno;
  594.       }
  595.       if (my_b_write(&log_file, (byte*) "n",1) ||
  596.   flush_io_cache(&log_file))
  597. error=errno;
  598.       if (error && ! write_error)
  599.       {
  600. write_error=1;
  601. sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
  602.       }
  603.       va_end(args);
  604.     }
  605.     VOID(pthread_mutex_unlock(&LOCK_log));
  606.     return error != 0;
  607.   }
  608.   return 0;
  609. }
  611. /* Write to binary log in a format to be used for replication */
  613. bool MYSQL_LOG::write(Query_log_event* event_info)
  614. {
  615.   /* In most cases this is only called if 'is_open()' is true */
  616.   bool error=0;
  617.   bool should_rotate = 0;
  618.   
  619.   if (!inited) // Can't use mutex if not init
  620.     return 0;
  621.   VOID(pthread_mutex_lock(&LOCK_log));
  622.   if (is_open())
  623.   {
  624.     THD *thd=event_info->thd;
  625.     IO_CACHE *file = (event_info->cache_stmt ? &thd->transaction.trans_log :
  626.       &log_file);
  627.     if ((!(thd->options & OPTION_BIN_LOG) &&
  628.  (thd->master_access & PROCESS_ACL)) ||
  629. !db_ok(event_info->db, binlog_do_db, binlog_ignore_db))
  630.     {
  631.       VOID(pthread_mutex_unlock(&LOCK_log));
  632.       return 0;
  633.     }
  634.     error=1;
  636.     if (thd->last_insert_id_used)
  637.     {
  638.       Intvar_log_event e((uchar)LAST_INSERT_ID_EVENT, thd->last_insert_id);
  639.       if (e.write(file))
  640. goto err;
  641.     }
  642.     if (thd->insert_id_used)
  643.     {
  644.       Intvar_log_event e((uchar)INSERT_ID_EVENT, thd->last_insert_id);
  645.       if (e.write(file))
  646. goto err;
  647.     }
  648.     if (thd->convert_set)
  649.     {
  650.       char buf[1024] = "SET CHARACTER SET ";
  651.       char* p = strend(buf);
  652.       p = strmov(p, thd->convert_set->name);
  653.       int save_query_length = thd->query_length;
  654.       // just in case somebody wants it later
  655.       thd->query_length = (uint)(p - buf);
  656.       Query_log_event e(thd, buf);
  657.       if (e.write(file))
  658. goto err;
  659.       thd->query_length = save_query_length; // clean up
  660.     }
  661.     if (event_info->write(file) ||
  662. file == &log_file && flush_io_cache(file))
  663.       goto err;
  664.     error=0;
  665.     should_rotate = (file == &log_file && my_b_tell(file) >= max_binlog_size); 
  666. err:
  667.     if (error)
  668.     {
  669.       if (my_errno == EFBIG)
  670. my_error(ER_TRANS_CACHE_FULL, MYF(0));
  671.       else
  672. my_error(ER_ERROR_ON_WRITE, MYF(0), name, errno);
  673.       write_error=1;
  674.     }
  675.     if (file == &log_file)
  676.       VOID(pthread_cond_broadcast(&COND_binlog_update));
  677.   }
  678.   VOID(pthread_mutex_unlock(&LOCK_log));
  679.   if(should_rotate)
  680.     new_file();
  681.   return error;
  682. }
  684. /*
  685.   Write a cached log entry to the binary log
  686.   We only come here if there is something in the cache.
  687.   'cache' needs to be reinitialized after this functions returns.
  688. */
  690. bool MYSQL_LOG::write(IO_CACHE *cache)
  691. {
  692.   VOID(pthread_mutex_lock(&LOCK_log));
  693.   bool error=1;
  694.   
  695.   if (is_open())
  696.   {
  697.     uint length;
  699.     if (reinit_io_cache(cache, READ_CACHE, 0, 0, 0))
  700.     {
  701.       sql_print_error(ER(ER_ERROR_ON_WRITE), cache->file_name, errno);
  702.       goto err;
  703.     }
  704.     length=my_b_bytes_in_cache(cache);
  705.     do
  706.     {
  707.       if (my_b_write(&log_file, cache->rc_pos, length))
  708.       {
  709. if (!write_error)
  710.   sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
  711. goto err;
  712.       }
  713.       cache->rc_pos=cache->rc_end; // Mark buffer used up
  714.     } while ((length=my_b_fill(cache)));
  715.     if (flush_io_cache(&log_file))
  716.     {
  717.       if (!write_error)
  718. sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
  719.       goto err;
  720.     }
  721.     if (cache->error) // Error on read
  722.     {
  723.       sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno);
  724.       goto err;
  725.     }
  726.   }
  727.   error=0;
  729. err:
  730.   if (error)
  731.     write_error=1;
  732.   else
  733.     VOID(pthread_cond_broadcast(&COND_binlog_update));
  734.     
  735.   VOID(pthread_mutex_unlock(&LOCK_log));
  736.   
  737.   return error;
  738. }
  741. bool MYSQL_LOG::write(Load_log_event* event_info)
  742. {
  743.   bool error=0;
  744.   bool should_rotate = 0;
  745.   
  746.   if (inited)
  747.   {
  748.     VOID(pthread_mutex_lock(&LOCK_log));
  749.     if (is_open())
  750.     {
  751.       THD *thd=event_info->thd;
  752.       if ((thd->options & OPTION_BIN_LOG) ||
  753.   !(thd->master_access & PROCESS_ACL))
  754.       {
  755. if (event_info->write(&log_file) || flush_io_cache(&log_file))
  756. {
  757.   if (!write_error)
  758.     sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
  759.   error=write_error=1;
  760. }
  761. should_rotate = (my_b_tell(&log_file) >= max_binlog_size);
  762. VOID(pthread_cond_broadcast(&COND_binlog_update));
  763.       }
  764.     }
  765.     VOID(pthread_mutex_unlock(&LOCK_log));
  766.   }
  768.   if(should_rotate)
  769.     new_file();
  770.   
  771.   return error;
  772. }
  775. /* Write update log in a format suitable for incremental backup */
  777. bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
  778.       time_t query_start)
  779. {
  780.   bool error=0;
  781.   if (is_open())
  782.   {
  783.     time_t current_time;
  784.     VOID(pthread_mutex_lock(&LOCK_log));
  785.     if (is_open())
  786.     { // Safety agains reopen
  787.       int tmp_errno=0;
  788.       char buff[80],*end;
  789.       end=buff;
  790.       if (!(thd->options & OPTION_UPDATE_LOG) &&
  791.   (thd->master_access & PROCESS_ACL))
  792.       {
  793. VOID(pthread_mutex_unlock(&LOCK_log));
  794. return 0;
  795.       }
  796.       if ((specialflag & SPECIAL_LONG_LOG_FORMAT) || query_start)
  797.       {
  798. current_time=time(NULL);
  799. if (current_time != last_time)
  800. {
  801.   last_time=current_time;
  802.   struct tm tm_tmp;
  803.   struct tm *start;
  804.   localtime_r(&current_time,&tm_tmp);
  805.   start=&tm_tmp;
  806.   /* Note that my_b_write() assumes it knows the length for this */
  807.   sprintf(buff,"# Time: %02d%02d%02d %2d:%02d:%02dn",
  808.   start->tm_year % 100,
  809.   start->tm_mon+1,
  810.   start->tm_mday,
  811.   start->tm_hour,
  812.   start->tm_min,
  813.   start->tm_sec);
  814.   if (my_b_write(&log_file, (byte*) buff,24))
  815.     tmp_errno=errno;
  816. }
  817. if (my_b_printf(&log_file, "# User@Host: %s[%s] @ %s [%s]n",
  818. thd->priv_user,
  819. thd->user,
  820. thd->host ? thd->host : "",
  821. thd->ip ? thd->ip : "") == (uint) -1)
  822.   tmp_errno=errno;
  823.       }
  824.       if (query_start)
  825.       {
  826. /* For slow query log */
  827. if (my_b_printf(&log_file,
  828. "# Time: %lu  Lock_time: %lu  Rows_sent: %lun",
  829. (ulong) (current_time - query_start),
  830. (ulong) (thd->time_after_lock - query_start),
  831. (ulong) thd->sent_row_count) == (uint) -1)
  832.     tmp_errno=errno;
  833.       }
  834.       if (thd->db && strcmp(thd->db,db))
  835.       { // Database changed
  836. if (my_b_printf(&log_file,"use %s;n",thd->db) == (uint) -1)
  837.   tmp_errno=errno;
  838. strmov(db,thd->db);
  839.       }
  840.       if (thd->last_insert_id_used)
  841.       {
  842. end=strmov(end,",last_insert_id=");
  843. end=longlong10_to_str((longlong) thd->current_insert_id,end,-10);
  844.       }
  845.       // Save value if we do an insert.
  846.       if (thd->insert_id_used)
  847.       {
  848. if (specialflag & SPECIAL_LONG_LOG_FORMAT)
  849. {
  850.   end=strmov(end,",insert_id=");
  851.   end=longlong10_to_str((longlong) thd->last_insert_id,end,-10);
  852. }
  853.       }
  854.       if (thd->query_start_used)
  855.       {
  856. if (query_start != thd->query_start())
  857. {
  858.   query_start=thd->query_start();
  859.   end=strmov(end,",timestamp=");
  860.   end=int10_to_str((long) query_start,end,10);
  861. }
  862.       }
  863.       if (end != buff)
  864.       {
  865. *end++=';';
  866. *end++='n';
  867. *end=0;
  868. if (my_b_write(&log_file, (byte*) "SET ",4) ||
  869.     my_b_write(&log_file, (byte*) buff+1,(uint) (end-buff)-1))
  870.   tmp_errno=errno;
  871.       }
  872.       if (!query)
  873.       {
  874. query="#adminstrator command";
  875. query_length=21;
  876.       }
  877.       if (my_b_write(&log_file, (byte*) query,query_length) ||
  878.   my_b_write(&log_file, (byte*) ";n",2) ||
  879.   flush_io_cache(&log_file))
  880. tmp_errno=errno;
  881.       if (tmp_errno)
  882.       {
  883. error=1;
  884. if (! write_error)
  885. {
  886.   write_error=1;
  887.   sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
  888. }
  889.       }
  890.     }
  891.     VOID(pthread_mutex_unlock(&LOCK_log));
  892.   }
  893.   return error;
  894. }
  897. void MYSQL_LOG::close(bool exiting)
  898. { // One can't set log_type here!
  899.   if (is_open())
  900.   {
  901.     File file=log_file.file;
  902.     if (log_type == LOG_BIN)
  903.     {
  904.       Stop_log_event s;
  905.       s.write(&log_file);
  906.       VOID(pthread_cond_broadcast(&COND_binlog_update));
  907.     }
  908.     end_io_cache(&log_file);
  909.     if (my_close(file,MYF(0)) < 0 && ! write_error)
  910.     {
  911.       write_error=1;
  912.       sql_print_error(ER(ER_ERROR_ON_WRITE),name,errno);
  913.     }
  914.   }
  915.   if (exiting && index_file >= 0)
  916.   {
  917.     if (my_close(index_file,MYF(0)) < 0 && ! write_error)
  918.     {
  919.       write_error=1;
  920.       sql_print_error(ER(ER_ERROR_ON_WRITE),name,errno);
  921.     }
  922.     index_file=-1;
  923.     log_type=LOG_CLOSED;
  924.   }
  925.   safeFree(name);
  926. }
  929. /* Check if a string is a valid number */
  930. /* Output: TRUE -> number */
  932. static bool test_if_number(register const char *str,
  933.    long *res, bool allow_wildcards)
  934. {
  935.   reg2 int flag;
  936.   const char *start;
  937.   DBUG_ENTER("test_if_number");
  939.   flag=0; start=str;
  940.   while (*str++ == ' ') ;
  941.   if (*--str == '-' || *str == '+')
  942.     str++;
  943.   while (isdigit(*str) || (allow_wildcards &&
  944.    (*str == wild_many || *str == wild_one)))
  945.   {
  946.     flag=1;
  947.     str++;
  948.   }
  949.   if (*str == '.')
  950.   {
  951.     for (str++ ;
  952.  isdigit(*str) ||
  953.    (allow_wildcards && (*str == wild_many || *str == wild_one)) ;
  954.  str++, flag=1) ;
  955.   }
  956.   if (*str != 0 || flag == 0)
  957.     DBUG_RETURN(0);
  958.   if (res)
  959.     *res=atol(start);
  960.   DBUG_RETURN(1); /* Number ok */
  961. } /* test_if_number */
  964. void sql_print_error(const char *format,...)
  965. {
  966.   va_list args;
  967.   time_t skr;
  968.   struct tm tm_tmp;
  969.   struct tm *start;
  970.   va_start(args,format);
  971.   DBUG_ENTER("sql_print_error");
  973.   VOID(pthread_mutex_lock(&LOCK_error_log));
  974. #ifndef DBUG_OFF
  975.   {
  976.     char buff[1024];
  977.     my_vsnprintf(buff,sizeof(buff)-1,format,args);
  978.     DBUG_PRINT("error",("%s",buff));
  979.   }
  980. #endif
  981.   skr=time(NULL);
  982.   localtime_r(&skr,&tm_tmp);
  983.   start=&tm_tmp;
  984.   fprintf(stderr,"%02d%02d%02d %2d:%02d:%02d  ",
  985.   start->tm_year % 100,
  986.   start->tm_mon+1,
  987.   start->tm_mday,
  988.   start->tm_hour,
  989.   start->tm_min,
  990.   start->tm_sec);
  991.   (void) vfprintf(stderr,format,args);
  992.   (void) fputc('n',stderr);
  993.   fflush(stderr);
  994.   va_end(args);
  996.   VOID(pthread_mutex_unlock(&LOCK_error_log));
  997.   DBUG_VOID_RETURN;
  998. }
  1002. void sql_perror(const char *message)
  1003. {
  1004. #ifdef HAVE_STRERROR
  1005.   sql_print_error("%s: %s",message, strerror(errno));
  1006. #else
  1007.   perror(message);
  1008. #endif
  1009. }