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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mysqlbinlog.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：32k
源码类别：

MySQL数据库

开发平台：

Visual C++

mysqlbinlog.cpp：源码内容
  1. /* Copyright (C) 2001-2004 MySQL AB
  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.
  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.
  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 */
  17. #define MYSQL_CLIENT
  18. #undef MYSQL_SERVER
  19. #include "client_priv.h"
  20. #include <my_time.h>
  21. #include "log_event.h"
  23. #define BIN_LOG_HEADER_SIZE 4
  24. #define PROBE_HEADER_LEN (EVENT_LEN_OFFSET+4)
  27. #define CLIENT_CAPABILITIES (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_LOCAL_FILES)
  29. char server_version[SERVER_VERSION_LENGTH];
  30. ulong server_id = 0;
  32. // needed by net_serv.c
  33. ulong bytes_sent = 0L, bytes_received = 0L;
  34. ulong mysqld_net_retry_count = 10L;
  35. ulong open_files_limit;
  36. uint test_flags = 0; 
  37. static uint opt_protocol= 0;
  38. static FILE *result_file;
  40. #ifndef DBUG_OFF
  41. static const char* default_dbug_option = "d:t:o,/tmp/mysqlbinlog.trace";
  42. #endif
  43. static const char *load_default_groups[]= { "mysqlbinlog","client",0 };
  45. void sql_print_error(const char *format, ...);
  47. static bool one_database=0, to_last_remote_log= 0, disable_log_bin= 0;
  48. static const char* database= 0;
  49. static my_bool force_opt= 0, short_form= 0, remote_opt= 0;
  50. static ulonglong offset = 0;
  51. static const char* host = 0;
  52. static int port = MYSQL_PORT;
  53. static const char* sock= 0;
  54. static const char* user = 0;
  55. static char* pass = 0;
  57. static ulonglong start_position, stop_position;
  58. #define start_position_mot ((my_off_t)start_position)
  59. #define stop_position_mot  ((my_off_t)stop_position)
  61. static char *start_datetime_str, *stop_datetime_str;
  62. static my_time_t start_datetime= 0, stop_datetime= MY_TIME_T_MAX;
  63. static ulonglong rec_count= 0;
  64. static short binlog_flags = 0; 
  65. static MYSQL* mysql = NULL;
  66. static const char* dirname_for_local_load= 0;
  67. static bool stop_passed= 0;
  69. static int dump_local_log_entries(const char* logname);
  70. static int dump_remote_log_entries(const char* logname);
  71. static int dump_log_entries(const char* logname);
  72. static int dump_remote_file(NET* net, const char* fname);
  73. static void die(const char* fmt, ...);
  74. static MYSQL* safe_connect();
  77. class Load_log_processor
  78. {
  79.   char target_dir_name[FN_REFLEN];
  80.   int target_dir_name_len;
  81.   DYNAMIC_ARRAY file_names;
  83.   /*
  84.     Looking for new uniquie filename that doesn't exist yet by 
  85.     adding postfix -%x
  87.     SYNOPSIS 
  88.        create_unique_file()
  89.        
  90.        filename       buffer for filename
  91.        file_name_end  tail of buffer that should be changed
  92.                       should point to a memory enough to printf("-%x",..)
  94.     RETURN VALUES
  95.       values less than 0      - can't find new filename
  96.       values great or equal 0 - created file with found filename
  97.   */
  98.   File create_unique_file(char *filename, char *file_name_end)
  99.     {
  100.       File res;
  101.       /* If we have to try more than 1000 times, something is seriously wrong */
  102.       for (uint version= 0; version<1000; version++)
  103.       {
  104. sprintf(file_name_end,"-%x",version);
  105. if ((res= my_create(filename,0,
  106.     O_CREAT|O_EXCL|O_BINARY|O_WRONLY,MYF(0)))!=-1)
  107.   return res;
  108.       }
  109.       return -1;
  110.     }
  112. public:
  113.   Load_log_processor() {}
  114.   ~Load_log_processor()
  115.   {
  116.     destroy();
  117.     delete_dynamic(&file_names);
  118.   }
  120.   int init()
  121.   {
  122.     return init_dynamic_array(&file_names,sizeof(Create_file_log_event*),
  123.       100,100 CALLER_INFO);
  124.   }
  126.   void init_by_dir_name(const char *dir)
  127.     {
  128.       target_dir_name_len= (convert_dirname(target_dir_name, dir, NullS) -
  129.     target_dir_name);
  130.     }
  131.   void init_by_cur_dir()
  132.     {
  133.       if (my_getwd(target_dir_name,sizeof(target_dir_name),MYF(MY_WME)))
  134. exit(1);
  135.       target_dir_name_len= strlen(target_dir_name);
  136.     }
  137.   void destroy()
  138.     {
  139.       Create_file_log_event **ptr= (Create_file_log_event**)file_names.buffer;
  140.       Create_file_log_event **end= ptr + file_names.elements;
  141.       for (; ptr<end; ptr++)
  142.       {
  143. if (*ptr)
  144. {
  145.   my_free((char*)(*ptr)->fname,MYF(MY_WME));
  146.   delete *ptr;
  147.   *ptr= 0;
  148. }
  149.       }
  150.     }
  151.   Create_file_log_event *grab_event(uint file_id)
  152.     {
  153.       if (file_id >= file_names.elements)
  154.         return 0;
  155.       Create_file_log_event **ptr= 
  156. (Create_file_log_event**)file_names.buffer + file_id;
  157.       Create_file_log_event *res= *ptr;
  158.       *ptr= 0;
  159.       return res;
  160.     }
  161.   int process(Create_file_log_event *ce);
  162.   int process(Append_block_log_event *ae);
  163.   File prepare_new_file_for_old_format(Load_log_event *le, char *filename);
  164.   int load_old_format_file(NET* net, const char *server_fname,
  165.    uint server_fname_len, File file);
  166. };
  170. File Load_log_processor::prepare_new_file_for_old_format(Load_log_event *le,
  171.  char *filename)
  172. {
  173.   uint len;
  174.   char *tail;
  175.   File file;
  176.   
  177.   fn_format(filename, le->fname, target_dir_name, "", 1);
  178.   len= strlen(filename);
  179.   tail= filename + len;
  180.   
  181.   if ((file= create_unique_file(filename,tail)) < 0)
  182.   {
  183.     sql_print_error("Could not construct local filename %s",filename);
  184.     return -1;
  185.   }
  186.   
  187.   le->set_fname_outside_temp_buf(filename,len+strlen(tail));
  188.   
  189.   return file;
  190. }
  193. int Load_log_processor::load_old_format_file(NET* net, const char*server_fname,
  194.      uint server_fname_len, File file)
  195. {
  196.   char buf[FN_REFLEN+1];
  197.   buf[0] = 0;
  198.   memcpy(buf + 1, server_fname, server_fname_len + 1);
  199.   if (my_net_write(net, buf, server_fname_len +2) || net_flush(net))
  200.   {
  201.     sql_print_error("Failed  requesting the remote dump of %s", server_fname);
  202.     return -1;
  203.   }
  204.   
  205.   for (;;)
  206.   {
  207.     ulong packet_len = my_net_read(net);
  208.     if (packet_len == 0)
  209.     {
  210.       if (my_net_write(net, "", 0) || net_flush(net))
  211.       {
  212. sql_print_error("Failed sending the ack packet");
  213. return -1;
  214.       }
  215.       /*
  216. we just need to send something, as the server will read but
  217. not examine the packet - this is because mysql_load() sends 
  218. an OK when it is done
  219.       */
  220.       break;
  221.     }
  222.     else if (packet_len == packet_error)
  223.     {
  224.       sql_print_error("Failed reading a packet during the dump of %s ", 
  225.       server_fname);
  226.       return -1;
  227.     }
  228.     
  229.     if (packet_len > UINT_MAX)
  230.     {
  231.       sql_print_error("Illegal length of packet read from net");
  232.       return -1;
  233.     }
  234.     if (my_write(file, (byte*) net->read_pos, 
  235.  (uint) packet_len, MYF(MY_WME|MY_NABP)))
  236.       return -1;
  237.   }
  238.   
  239.   return 0;
  240. }
  243. int Load_log_processor::process(Create_file_log_event *ce)
  244. {
  245.   const char *bname= ce->fname+dirname_length(ce->fname);
  246.   uint blen= ce->fname_len - (bname-ce->fname);
  247.   uint full_len= target_dir_name_len + blen + 9 + 9 + 1;
  248.   int error= 0;
  249.   char *fname, *ptr;
  250.   File file;
  251.   DBUG_ENTER("Load_log_processor::process");
  253.   if (set_dynamic(&file_names,(gptr)&ce,ce->file_id))
  254.   {
  255.     sql_print_error("Could not construct local filename %s%s",
  256.     target_dir_name,bname);
  257.     DBUG_RETURN(-1);
  258.   }
  259.   if (!(fname= my_malloc(full_len,MYF(MY_WME))))
  260.     DBUG_RETURN(-1);
  262.   memcpy(fname, target_dir_name, target_dir_name_len);
  263.   ptr= fname + target_dir_name_len;
  264.   memcpy(ptr,bname,blen);
  265.   ptr+= blen;
  266.   ptr+= my_sprintf(ptr,(ptr,"-%x",ce->file_id));
  268.   if ((file= create_unique_file(fname,ptr)) < 0)
  269.   {
  270.     sql_print_error("Could not construct local filename %s%s",
  271.     target_dir_name,bname);
  272.     DBUG_RETURN(-1);
  273.   }
  274.   ce->set_fname_outside_temp_buf(fname,strlen(fname));
  276.   if (my_write(file,(byte*) ce->block,ce->block_len,MYF(MY_WME|MY_NABP)))
  277.     error= -1;
  278.   if (my_close(file, MYF(MY_WME)))
  279.     error= -1;
  280.   DBUG_RETURN(error);
  281. }
  284. int Load_log_processor::process(Append_block_log_event *ae)
  285. {
  286.   DBUG_ENTER("Load_log_processor::process");
  287.   Create_file_log_event* ce= ((ae->file_id < file_names.elements) ?
  288.       *((Create_file_log_event**)file_names.buffer +
  289. ae->file_id) :
  290.       0);
  292.   if (ce)
  293.   {
  294.     File file;
  295.     int error= 0;
  296.     if (((file= my_open(ce->fname,
  297. O_APPEND|O_BINARY|O_WRONLY,MYF(MY_WME))) < 0))
  298.       DBUG_RETURN(-1);
  299.     if (my_write(file,(byte*)ae->block,ae->block_len,MYF(MY_WME|MY_NABP)))
  300.       error= -1;
  301.     if (my_close(file,MYF(MY_WME)))
  302.       error= -1;
  303.     DBUG_RETURN(error);
  304.   }
  306.   /*
  307.     There is no Create_file event (a bad binlog or a big
  308.     --position). Assuming it's a big --position, we just do nothing and
  309.     print a warning.
  310.   */
  311.   fprintf(stderr,"Warning: ignoring Append_block as there is no 
  312. Create_file event for file_id: %un",ae->file_id);
  313.   DBUG_RETURN(-1);
  314. }
  317. Load_log_processor load_processor;
  319. /*
  320.   RETURN
  321.     0           ok and continue
  322.     1           error and terminate
  323.     -1          ok and terminate
  325.   TODO
  326.     This function returns 0 even in some error cases. This should be changed.
  327. */
  328. int process_event(char *last_db, Log_event *ev, my_off_t pos, int old_format)
  329. {
  330.   char ll_buff[21];
  331.   DBUG_ENTER("process_event");
  333.   if ((rec_count >= offset) &&
  334.       ((my_time_t)(ev->when) >= start_datetime))
  335.   {
  336.     /*
  337.       We have found an event after start_datetime, from now on print
  338.       everything (in case the binlog has timestamps increasing and decreasing,
  339.       we do this to avoid cutting the middle).
  340.     */
  341.     start_datetime= 0;
  342.     offset= 0; // print everything and protect against cycling rec_count
  343.     if (((my_time_t)(ev->when) >= stop_datetime)
  344.         || (pos >= stop_position_mot))
  345.     {
  346.       stop_passed= 1; // skip all next binlogs
  347.       DBUG_RETURN(-1);
  348.     }
  349.     if (!short_form)
  350.       fprintf(result_file, "# at %sn",llstr(pos,ll_buff));
  351.     
  352.     switch (ev->get_type_code()) {
  353.     case QUERY_EVENT:
  354.       if (one_database)
  355.       {
  356. const char * log_dbname = ((Query_log_event*)ev)->db;
  357. if ((log_dbname != NULL) && (strcmp(log_dbname, database)))
  358.   goto end;
  359.       }
  360.       ev->print(result_file, short_form, last_db);
  361.       break;
  362.     case CREATE_FILE_EVENT:
  363.     {
  364.       Create_file_log_event* ce= (Create_file_log_event*)ev;
  365.       if (one_database)
  366.       {
  367. /*
  368.   We test if this event has to be ignored. If yes, we don't save 
  369.       this event; this will have the good side-effect of ignoring all 
  370.       related Append_block and Exec_load.
  371.       Note that Load event from 3.23 is not tested.
  372. */
  373. const char * log_dbname = ce->db;            
  374. if ((log_dbname != NULL) && (strcmp(log_dbname, database)))
  375.   goto end; // Next event
  376.       }
  377.       /*
  378. We print the event, but with a leading '#': this is just to inform 
  379. the user of the original command; the command we want to execute 
  380. will be a derivation of this original command (we will change the 
  381. filename and use LOCAL), prepared in the 'case EXEC_LOAD_EVENT' 
  382. below.
  383.       */
  384.       ce->print(result_file, short_form, last_db, TRUE);
  385.       if (!old_format)
  386.       {
  387. if (load_processor.process(ce))
  388.   break; // Error
  389. ev= 0;
  390.       }
  391.       break;
  392.     }
  393.     case APPEND_BLOCK_EVENT:
  394.       ev->print(result_file, short_form, last_db);
  395.       if (load_processor.process((Append_block_log_event*) ev))
  396. break; // Error
  397.       break;
  398.     case EXEC_LOAD_EVENT:
  399.     {
  400.       ev->print(result_file, short_form, last_db);
  401.       Execute_load_log_event *exv= (Execute_load_log_event*)ev;
  402.       Create_file_log_event *ce= load_processor.grab_event(exv->file_id);
  403.       /*
  404. if ce is 0, it probably means that we have not seen the Create_file
  405. event (a bad binlog, or most probably --position is after the
  406. Create_file event). Print a warning comment.
  407.       */
  408.       if (ce)
  409.       {
  410. ce->print(result_file, short_form, last_db, TRUE);
  411. my_free((char*)ce->fname,MYF(MY_WME));
  412. delete ce;
  413.       }
  414.       else
  415. fprintf(stderr,"Warning: ignoring Exec_load as there is no 
  416. Create_file event for file_id: %un",exv->file_id);
  417.       break;
  418.     }
  419.     default:
  420.       ev->print(result_file, short_form, last_db);
  421.     }
  422.   }
  424. end:
  425.   rec_count++;
  426.   if (ev)
  427.     delete ev;
  428.   DBUG_RETURN(0);
  429. }
  432. static struct my_option my_long_options[] =
  433. {
  435. #ifdef __NETWARE__
  436.   {"auto-close", OPT_AUTO_CLOSE, "Auto close the screen on exit for Netware.",
  437.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  438. #endif
  439. #ifndef DBUG_OFF
  440.   {"debug", '#', "Output debug log.", (gptr*) &default_dbug_option,
  441.    (gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  442. #endif
  443.   {"database", 'd', "List entries for just this database (local log only).",
  444.    (gptr*) &database, (gptr*) &database, 0, GET_STR_ALLOC, REQUIRED_ARG,
  445.    0, 0, 0, 0, 0, 0},
  446.   {"disable-log-bin", 'D', "Disable binary log. This is useful, if you "
  447.     "enabled --to-last-log and are sending the output to the same MySQL server. "
  448.     "This way you could avoid an endless loop. You would also like to use it "
  449.     "when restoring after a crash to avoid duplication of the statements you "
  450.     "already have. NOTE: you will need a SUPER privilege to use this option.",
  451.    (gptr*) &disable_log_bin, (gptr*) &disable_log_bin, 0, GET_BOOL,
  452.    NO_ARG, 0, 0, 0, 0, 0, 0},
  453.   {"force-read", 'f', "Force reading unknown binlog events.",
  454.    (gptr*) &force_opt, (gptr*) &force_opt, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  455.    0, 0},
  456.   {"help", '?', "Display this help and exit.",
  457.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  458.   {"host", 'h', "Get the binlog from server.", (gptr*) &host, (gptr*) &host,
  459.    0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  460.   {"offset", 'o', "Skip the first N entries.", (gptr*) &offset, (gptr*) &offset,
  461.    0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  462.   {"password", 'p', "Password to connect to remote server.",
  463.    0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  464.   {"port", 'P', "Use port to connect to the remote server.",
  465.    (gptr*) &port, (gptr*) &port, 0, GET_INT, REQUIRED_ARG, MYSQL_PORT, 0, 0,
  466.    0, 0, 0},
  467.   {"position", 'j', "Deprecated. Use --start-position instead.",
  468.    (gptr*) &start_position, (gptr*) &start_position, 0, GET_ULL,
  469.    REQUIRED_ARG, BIN_LOG_HEADER_SIZE, BIN_LOG_HEADER_SIZE,
  470.    /* COM_BINLOG_DUMP accepts only 4 bytes for the position */
  471.    (ulonglong)(~(uint32)0), 0, 0, 0},
  472.   {"protocol", OPT_MYSQL_PROTOCOL,
  473.    "The protocol of connection (tcp,socket,pipe,memory).",
  474.    0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  475.   {"result-file", 'r', "Direct output to a given file.", 0, 0, 0, GET_STR,
  476.    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  477.   {"read-from-remote-server", 'R', "Read binary logs from a MySQL server",
  478.    (gptr*) &remote_opt, (gptr*) &remote_opt, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  479.    0, 0},
  480.   {"open_files_limit", OPT_OPEN_FILES_LIMIT,
  481.    "Used to reserve file descriptors for usage by this program",
  482.    (gptr*) &open_files_limit, (gptr*) &open_files_limit, 0, GET_ULONG,
  483.    REQUIRED_ARG, MY_NFILE, 8, OS_FILE_LIMIT, 0, 1, 0},
  484.   {"short-form", 's', "Just show the queries, no extra info.",
  485.    (gptr*) &short_form, (gptr*) &short_form, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  486.    0, 0},
  487.   {"socket", 'S', "Socket file to use for connection.",
  488.    (gptr*) &sock, (gptr*) &sock, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 
  489.    0, 0},
  490.   {"start-datetime", OPT_START_DATETIME,
  491.    "Start reading the binlog at first event having a datetime equal or "
  492.    "posterior to the argument; the argument must be a date and time "
  493.    "in the local time zone, in any format accepted by the MySQL server "
  494.    "for DATETIME and TIMESTAMP types, for example: 2004-12-25 11:25:56 "
  495.    "(you should probably use quotes for your shell to set it properly).",
  496.    (gptr*) &start_datetime_str, (gptr*) &start_datetime_str,
  497.    0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  498.   {"stop-datetime", OPT_STOP_DATETIME,
  499.    "Stop reading the binlog at first event having a datetime equal or "
  500.    "posterior to the argument; the argument must be a date and time "
  501.    "in the local time zone, in any format accepted by the MySQL server "
  502.    "for DATETIME and TIMESTAMP types, for example: 2004-12-25 11:25:56 "
  503.    "(you should probably use quotes for your shell to set it properly).",
  504.    (gptr*) &stop_datetime_str, (gptr*) &stop_datetime_str,
  505.    0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  506.   {"start-position", OPT_START_POSITION,
  507.    "Start reading the binlog at position N. Applies to the first binlog "
  508.    "passed on the command line.",
  509.    (gptr*) &start_position, (gptr*) &start_position, 0, GET_ULL,
  510.    REQUIRED_ARG, BIN_LOG_HEADER_SIZE, BIN_LOG_HEADER_SIZE,
  511.    /* COM_BINLOG_DUMP accepts only 4 bytes for the position */
  512.    (ulonglong)(~(uint32)0), 0, 0, 0},
  513.   {"stop-position", OPT_STOP_POSITION,
  514.    "Stop reading the binlog at position N. Applies to the last binlog "
  515.    "passed on the command line.",
  516.    (gptr*) &stop_position, (gptr*) &stop_position, 0, GET_ULL,
  517.    REQUIRED_ARG, (ulonglong)(~(my_off_t)0), BIN_LOG_HEADER_SIZE,
  518.    (ulonglong)(~(my_off_t)0), 0, 0, 0},
  519.   {"to-last-log", 't', "Requires -R. Will not stop at the end of the 
  520. requested binlog but rather continue printing until the end of the last 
  521. binlog of the MySQL server. If you send the output to the same MySQL server, 
  522. that may lead to an endless loop.",
  523.    (gptr*) &to_last_remote_log, (gptr*) &to_last_remote_log, 0, GET_BOOL,
  524.    NO_ARG, 0, 0, 0, 0, 0, 0},
  525.   {"user", 'u', "Connect to the remote server as username.",
  526.    (gptr*) &user, (gptr*) &user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0,
  527.    0, 0},
  528.   {"local-load", 'l', "Prepare local temporary files for LOAD DATA INFILE in the specified directory.",
  529.    (gptr*) &dirname_for_local_load, (gptr*) &dirname_for_local_load, 0,
  530.    GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  531.   {"version", 'V', "Print version and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
  532.    0, 0, 0, 0, 0},
  533.   {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
  534. };
  537. void sql_print_error(const char *format,...)
  538. {
  539.   va_list args;
  540.   va_start(args, format);
  541.   fprintf(stderr, "ERROR: ");
  542.   vfprintf(stderr, format, args);
  543.   fprintf(stderr, "n");
  544.   va_end(args);
  545. }
  547. static void cleanup()
  548. {
  549.   my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
  550.   my_free((char*) database, MYF(MY_ALLOW_ZERO_PTR));
  551.   my_free((char*) host, MYF(MY_ALLOW_ZERO_PTR));
  552.   my_free((char*) user, MYF(MY_ALLOW_ZERO_PTR));
  553.   my_free((char*) dirname_for_local_load, MYF(MY_ALLOW_ZERO_PTR));
  554. }
  556. static void die(const char* fmt, ...)
  557. {
  558.   va_list args;
  559.   va_start(args, fmt);
  560.   fprintf(stderr, "ERROR: ");
  561.   vfprintf(stderr, fmt, args);
  562.   fprintf(stderr, "n");
  563.   va_end(args);
  564.   cleanup();
  565.   my_end(0);
  566.   exit(1);
  567. }
  569. #include <help_start.h>
  571. static void print_version()
  572. {
  573.   printf("%s Ver 3.0 for %s at %sn", my_progname, SYSTEM_TYPE, MACHINE_TYPE);
  574.   NETWARE_SET_SCREEN_MODE(1);
  575. }
  578. static void usage()
  579. {
  580.   print_version();
  581.   puts("By Monty and Sasha, for your professional usen
  582. This software comes with NO WARRANTY:  This is free software,n
  583. and you are welcome to modify and redistribute it under the GPL licensen");
  585.   printf("
  586. Dumps a MySQL binary log in a format usable for viewing or for piping ton
  587. the mysql command line clientnn");
  588.   printf("Usage: %s [options] log-filesn", my_progname);
  589.   my_print_help(my_long_options);
  590.   my_print_variables(my_long_options);
  591. }
  594. static my_time_t convert_str_to_timestamp(const char* str)
  595. {
  596.   int was_cut;
  597.   MYSQL_TIME l_time;
  598.   long dummy_my_timezone;
  599.   bool dummy_in_dst_time_gap;
  600.   /* We require a total specification (date AND time) */
  601.   if (str_to_datetime(str, strlen(str), &l_time, 0, &was_cut) !=
  602.       MYSQL_TIMESTAMP_DATETIME || was_cut)
  603.   {
  604.     fprintf(stderr, "Incorrect date and time argument: %sn", str);
  605.     exit(1);
  606.   }
  607.   /*
  608.     Note that Feb 30th, Apr 31st cause no error messages and are mapped to
  609.     the next existing day, like in mysqld. Maybe this could be changed when
  610.     mysqld is changed too (with its "strict" mode?).
  611.   */
  612.   return
  613.     my_system_gmt_sec(&l_time, &dummy_my_timezone, &dummy_in_dst_time_gap);
  614. }
  616. #include <help_end.h>
  618. extern "C" my_bool
  619. get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
  620.        char *argument)
  621. {
  622.   bool tty_password=0;
  623.   switch (optid) {
  624. #ifdef __NETWARE__
  625.   case OPT_AUTO_CLOSE:
  626.     setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
  627.     break;
  628. #endif
  629. #ifndef DBUG_OFF
  630.   case '#':
  631.     DBUG_PUSH(argument ? argument : default_dbug_option);
  632.     break;
  633. #endif
  634.   case 'd':
  635.     one_database = 1;
  636.     break;
  637.   case 'p':
  638.     if (argument)
  639.     {
  640.       my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
  641.       char *start=argument;
  642.       pass= my_strdup(argument,MYF(MY_FAE));
  643.       while (*argument) *argument++= 'x'; /* Destroy argument */
  644.       if (*start)
  645.         start[1]=0; /* Cut length of argument */
  646.     }
  647.     else
  648.       tty_password=1;
  649.     break;
  650.   case 'r':
  651.     if (!(result_file = my_fopen(argument, O_WRONLY | O_BINARY, MYF(MY_WME))))
  652.       exit(1);
  653.     break;
  654.   case 'R':
  655.     remote_opt= 1;
  656.     break;
  657.   case OPT_MYSQL_PROTOCOL:
  658.   {
  659.     if ((opt_protocol= find_type(argument, &sql_protocol_typelib,0)) <= 0)
  660.     {
  661.       fprintf(stderr, "Unknown option to protocol: %sn", argument);
  662.       exit(1);
  663.     }
  664.     break;
  665.   }
  666.   case OPT_START_DATETIME:
  667.     start_datetime= convert_str_to_timestamp(start_datetime_str);
  668.     break;
  669.   case OPT_STOP_DATETIME:
  670.     stop_datetime= convert_str_to_timestamp(stop_datetime_str);
  671.     break;
  672.   case 'V':
  673.     print_version();
  674.     exit(0);
  675.   case '?':
  676.     usage();
  677.     exit(0);
  678.   }
  679.   if (tty_password)
  680.     pass= get_tty_password(NullS);
  682.   return 0;
  683. }
  686. static int parse_args(int *argc, char*** argv)
  687. {
  688.   int ho_error;
  690.   result_file = stdout;
  691.   load_defaults("my",load_default_groups,argc,argv);
  692.   if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
  693.     exit(ho_error);
  695.   return 0;
  696. }
  698. static MYSQL* safe_connect()
  699. {
  700.   MYSQL *local_mysql= mysql_init(NULL);
  702.   if (!local_mysql)
  703.     die("Failed on mysql_init");
  705.   if (opt_protocol)
  706.     mysql_options(local_mysql, MYSQL_OPT_PROTOCOL, (char*) &opt_protocol);
  707.   if (!mysql_real_connect(local_mysql, host, user, pass, 0, port, sock, 0))
  708.   {
  709.     char errmsg[256];
  710.     strmake(errmsg, mysql_error(local_mysql), sizeof(errmsg)-1);
  711.     mysql_close(local_mysql);
  712.     die("failed on connect: %s", errmsg);
  713.   }
  714.   return local_mysql;
  715. }
  718. static int dump_log_entries(const char* logname)
  719. {
  720.   return (remote_opt ? dump_remote_log_entries(logname) :
  721.           dump_local_log_entries(logname));
  722. }
  725. static int check_master_version(MYSQL* mysql)
  726. {
  727.   MYSQL_RES* res = 0;
  728.   MYSQL_ROW row;
  729.   const char* version;
  730.   int old_format = 0;
  732.   if (mysql_query(mysql, "SELECT VERSION()") ||
  733.       !(res = mysql_store_result(mysql)))
  734.   {
  735.     char errmsg[256];
  736.     strmake(errmsg, mysql_error(mysql), sizeof(errmsg)-1);
  737.     mysql_close(mysql);
  738.     die("Error checking master version: %s", errmsg);
  739.   }
  740.   if (!(row = mysql_fetch_row(res)))
  741.   {
  742.     mysql_free_result(res);
  743.     mysql_close(mysql);
  744.     die("Master returned no rows for SELECT VERSION()");
  745.     return 1;
  746.   }
  747.   if (!(version = row[0]))
  748.   {
  749.     mysql_free_result(res);
  750.     mysql_close(mysql);
  751.     die("Master reported NULL for the version");
  752.   }
  754.   switch (*version) {
  755.   case '3':
  756.     old_format = 1;
  757.     break;
  758.   case '4':
  759.   case '5':
  760.     old_format = 0;
  761.     break;
  762.   default:
  763.     sql_print_error("Master reported unrecognized MySQL version '%s'",
  764.     version);
  765.     mysql_free_result(res);
  766.     mysql_close(mysql);
  767.     return 1;
  768.   }
  769.   mysql_free_result(res);
  770.   return old_format;
  771. }
  774. static int dump_remote_log_entries(const char* logname)
  775. {
  776.   char buf[128];
  777.   char last_db[FN_REFLEN+1] = "";
  778.   ulong len;
  779.   uint logname_len;
  780.   NET* net;
  781.   int old_format;
  782.   int error= 0;
  783.   my_off_t old_off= start_position_mot;
  784.   char fname[FN_REFLEN+1];
  785.   DBUG_ENTER("dump_remote_log_entries");
  787.   /*
  788.     Even if we already read one binlog (case of >=2 binlogs on command line),
  789.     we cannot re-use the same connection as before, because it is now dead
  790.     (COM_BINLOG_DUMP kills the thread when it finishes).
  791.   */
  792.   mysql= safe_connect();
  793.   net= &mysql->net;
  794.   old_format = check_master_version(mysql);
  796.   /*
  797.     COM_BINLOG_DUMP accepts only 4 bytes for the position, so we are forced to
  798.     cast to uint32.
  799.   */
  800.   int4store(buf, (uint32)start_position);
  801.   int2store(buf + BIN_LOG_HEADER_SIZE, binlog_flags);
  803.   size_s tlen = strlen(logname);
  804.   if (tlen > UINT_MAX) 
  805.   {
  806.     fprintf(stderr,"Log name too longn");
  807.     error= 1;
  808.     goto err;
  809.   }
  810.   logname_len = (uint) tlen;
  811.   int4store(buf + 6, 0);
  812.   memcpy(buf + 10, logname, logname_len);
  813.   if (simple_command(mysql, COM_BINLOG_DUMP, buf, logname_len + 10, 1))
  814.   {
  815.     fprintf(stderr,"Got fatal error sending the log dump commandn");
  816.     error= 1;
  817.     goto err;
  818.   }
  820.   for (;;)
  821.   {
  822.     const char *error_msg;
  823.     len = net_safe_read(mysql);
  824.     if (len == packet_error)
  825.     {
  826.       fprintf(stderr, "Got error reading packet from server: %sn",
  827.       mysql_error(mysql));
  828.       error= 1;
  829.       goto err;
  830.     }
  831.     if (len < 8 && net->read_pos[0] == 254)
  832.       break; // end of data
  833.     DBUG_PRINT("info",( "len= %u, net->read_pos[5] = %dn",
  834. len, net->read_pos[5]));
  835.     Log_event *ev = Log_event::read_log_event((const char*) net->read_pos + 1 ,
  836.       len - 1, &error_msg, old_format);
  837.     if (!ev)
  838.     {
  839.       fprintf(stderr, "Could not construct log event objectn");
  840.       error= 1;
  841.       goto err;
  842.     }   
  844.     Log_event_type type= ev->get_type_code();
  845.     if (!old_format || ( type != LOAD_EVENT && type != CREATE_FILE_EVENT))
  846.     {
  847.       if (ev->get_type_code() == ROTATE_EVENT)
  848.       {
  849.         Rotate_log_event *rev= (Rotate_log_event *)ev;
  850.         /*
  851.           mysqld is sending us all its binlogs after the requested one, but we
  852.           don't want them.
  853.           If this is a fake Rotate event, and not about our log, we can stop
  854.           transfer. If this a real Rotate event (so it's not about our log,
  855.           it's in our log describing the next log), we print it (because it's
  856.           part of our log) and then we will stop when we receive the fake one
  857.           soon.
  858.           This is suitable for binlogs, not relay logs (but for now we don't
  859.           read relay logs remotely because the server is not able to do
  860.           that). If one day we read relay logs remotely, then we will have a
  861.           problem with the detection below: relay logs contain Rotate events
  862.           which are about the binlogs, so which would trigger the end-detection
  863.           below.
  864.         */
  865.         if (rev->when == 0)
  866.         {
  867.           if (!to_last_remote_log)
  868.           {
  869.             if ((rev->ident_len != logname_len) ||
  870.                 memcmp(rev->new_log_ident, logname, logname_len))
  871.             {
  872.               error= 0;
  873.               goto err;
  874.             }
  875.             /*
  876.               Otherwise, this is a fake Rotate for our log, at the very
  877.               beginning for sure. Skip it, because it was not in the original
  878.               log. If we are running with to_last_remote_log, we print it,
  879.               because it serves as a useful marker between binlogs then.
  880.             */
  881.             continue;
  882.           }
  883.           len= 1; // fake Rotate, so don't increment old_off
  884.         }
  885.       }
  886.       if ((error= process_event(last_db,ev,old_off,old_format)))
  887.       {
  888. error= ((error < 0) ? 0 : 1);
  889.         goto err;
  890.       }
  891.     }
  892.     else
  893.     {
  894.       Load_log_event *le= (Load_log_event*)ev;
  895.       const char *old_fname= le->fname;
  896.       uint old_len= le->fname_len;
  897.       File file;
  899.       if ((file= load_processor.prepare_new_file_for_old_format(le,fname)) < 0)
  900.       {
  901.         error= 1;
  902.         goto err;
  903.       }
  905.       if ((error= process_event(last_db,ev,old_off,old_format)))
  906.       {
  907. my_close(file,MYF(MY_WME));
  908. error= ((error < 0) ? 0 : 1);
  909.         goto err;
  910.       }
  911.       if (load_processor.load_old_format_file(net,old_fname,old_len,file))
  912.       {
  913. my_close(file,MYF(MY_WME));
  914.         error= 1;
  915.         goto err;
  916.       }
  917.       my_close(file,MYF(MY_WME));
  918.     }
  919.     
  920.     /*
  921.       Let's adjust offset for remote log as for local log to produce 
  922.       similar text.
  923.     */
  924.     old_off+= len-1;
  925.   }
  926. err:
  927.   mysql_close(mysql);
  928.   DBUG_RETURN(error);
  929. }
  932. static int check_header(IO_CACHE* file)
  933. {
  934.   byte header[BIN_LOG_HEADER_SIZE];
  935.   byte buf[PROBE_HEADER_LEN];
  936.   int old_format=0;
  937.   DBUG_ENTER("check_header");
  939.   my_off_t pos = my_b_tell(file);
  940.   my_b_seek(file, (my_off_t)0);
  941.   if (my_b_read(file, header, sizeof(header)))
  942.     die("Failed reading header;  Probably an empty file");
  943.   if (memcmp(header, BINLOG_MAGIC, sizeof(header)))
  944.     die("File is not a binary log file");
  945.   if (!my_b_read(file, buf, sizeof(buf)))
  946.   {
  947.     if (buf[4] == START_EVENT)
  948.     {
  949.       uint event_len;
  950.       event_len = uint4korr(buf + EVENT_LEN_OFFSET);
  951.       old_format = (event_len < (LOG_EVENT_HEADER_LEN + START_HEADER_LEN));
  952.     }
  953.   }
  954.   my_b_seek(file, pos);
  955.   DBUG_RETURN(old_format);
  956. }
  959. static int dump_local_log_entries(const char* logname)
  960. {
  961.   File fd = -1;
  962.   IO_CACHE cache,*file= &cache;
  963.   char last_db[FN_REFLEN+1];
  964.   byte tmp_buff[BIN_LOG_HEADER_SIZE];
  965.   bool old_format = 0;
  966.   int error= 0;
  968.   last_db[0]= 0;
  970.   if (logname && logname[0] != '-')
  971.   {
  972.     if ((fd = my_open(logname, O_RDONLY | O_BINARY, MYF(MY_WME))) < 0)
  973.       return 1;
  974.     if (init_io_cache(file, fd, 0, READ_CACHE, start_position_mot, 0,
  975.       MYF(MY_WME | MY_NABP)))
  976.     {
  977.       my_close(fd, MYF(MY_WME));
  978.       exit(1);
  979.     }
  980.     old_format = check_header(file);
  981.   }
  982.   else
  983.   {
  984.     if (init_io_cache(file, fileno(result_file), 0, READ_CACHE, (my_off_t) 0,
  985.       0, MYF(MY_WME | MY_NABP | MY_DONT_CHECK_FILESIZE)))
  986.       return 1;
  987.     old_format = check_header(file);
  988.     if (start_position)
  989.     {
  990.       /* skip 'start_position' characters from stdout */
  991.       byte buff[IO_SIZE];
  992.       my_off_t length,tmp;
  993.       for (length= start_position_mot ; length > 0 ; length-=tmp)
  994.       {
  995. tmp=min(length,sizeof(buff));
  996. if (my_b_read(file, buff, (uint) tmp))
  997. {
  998.   error= 1;
  999.   goto end;
  1000. }
  1001.       }
  1002.     }
  1003.     file->pos_in_file= start_position_mot;
  1004.     file->seek_not_done=0;
  1005.   }
  1007.   if (!start_position)
  1008.   {
  1009.     // Skip header
  1010.     if (my_b_read(file, tmp_buff, BIN_LOG_HEADER_SIZE))
  1011.     {
  1012.       error= 1;
  1013.       goto end;
  1014.     }
  1015.   }
  1017.   for (;;)
  1018.   {
  1019.     char llbuff[21];
  1020.     my_off_t old_off = my_b_tell(file);
  1022.     Log_event* ev = Log_event::read_log_event(file, old_format);
  1023.     if (!ev)
  1024.     {
  1025.       if (file->error)
  1026.       {
  1027. fprintf(stderr,
  1028. "Could not read entry at offset %s:"
  1029. "Error in log format or read errorn",
  1030. llstr(old_off,llbuff));
  1031. error= 1;
  1032.       }
  1033.       // file->error == 0 means EOF, that's OK, we break in this case
  1034.       break;
  1035.     }
  1036.     if ((error= process_event(last_db,ev,old_off,false)))
  1037.     {
  1038.       if (error < 0)
  1039.         error= 0;
  1040.       break;
  1041.     }
  1042.   }
  1044. end:
  1045.   if (fd >= 0)
  1046.     my_close(fd, MYF(MY_WME));
  1047.   end_io_cache(file);
  1048.   return error;
  1049. }
  1052. int main(int argc, char** argv)
  1053. {
  1054.   static char **defaults_argv;
  1055.   int exit_value= 0;
  1056.   ulonglong save_stop_position;
  1057.   MY_INIT(argv[0]);
  1058.   DBUG_ENTER("main");
  1059.   DBUG_PROCESS(argv[0]);
  1061.   init_time(); // for time functions
  1063.   parse_args(&argc, (char***)&argv);
  1064.   defaults_argv=argv;
  1066.   if (!argc)
  1067.   {
  1068.     usage();
  1069.     free_defaults(defaults_argv);
  1070.     exit(1);
  1071.   }
  1073.   my_set_max_open_files(open_files_limit);
  1075.   MY_TMPDIR tmpdir;
  1076.   tmpdir.list= 0;
  1077.   if (!dirname_for_local_load)
  1078.   {
  1079.     if (init_tmpdir(&tmpdir, 0))
  1080.       exit(1);
  1081.     dirname_for_local_load= my_strdup(my_tmpdir(&tmpdir), MY_WME);
  1082.   }
  1084.   if (load_processor.init())
  1085.     exit(1);
  1086.   if (dirname_for_local_load)
  1087.     load_processor.init_by_dir_name(dirname_for_local_load);
  1088.   else
  1089.     load_processor.init_by_cur_dir();
  1091.   fprintf(result_file,
  1092.   "/*!40019 SET @@session.max_insert_delayed_threads=0*/;n");
  1094.   if (disable_log_bin)
  1095.     fprintf(result_file,
  1096.             "/*!32316 SET @OLD_SQL_LOG_BIN=@@SQL_LOG_BIN, SQL_LOG_BIN=0*/;n");
  1098.   for (save_stop_position= stop_position, stop_position= ~(my_off_t)0 ;
  1099.        (--argc >= 0) && !stop_passed ; )
  1100.   {
  1101.     if (argc == 0) // last log, --stop-position applies
  1102.       stop_position= save_stop_position;
  1103.     if (dump_log_entries(*(argv++)))
  1104.     {
  1105.       exit_value=1;
  1106.       break;
  1107.     }
  1108.     // For next log, --start-position does not apply
  1109.     start_position= BIN_LOG_HEADER_SIZE;
  1110.   }
  1112.   if (disable_log_bin)
  1113.     fprintf(result_file, "/*!32316 SET SQL_LOG_BIN=@OLD_SQL_LOG_BIN*/;n");
  1115.   if (tmpdir.list)
  1116.     free_tmpdir(&tmpdir);
  1117.   if (result_file != stdout)
  1118.     my_fclose(result_file, MYF(0));
  1119.   cleanup();
  1120.   free_defaults(defaults_argv);
  1121.   my_free_open_file_info();
  1122.   my_end(0);
  1123.   exit(exit_value);
  1124.   DBUG_RETURN(exit_value); // Keep compilers happy
  1125. }
  1127. /*
  1128.   We must include this here as it's compiled with different options for
  1129.   the server
  1130. */
  1132. #ifdef __WIN__
  1133. #include "log_event.cpp"
  1134. #else
  1135. #include "log_event.cc"
  1136. #endif
  1138. FIX_GCC_LINKING_PROBLEM