mysqlbinlog.cc 24 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2001-2004 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#define MYSQL_CLIENT
#undef MYSQL_SERVER
unknown's avatar
unknown committed
19
#include "client_priv.h"
unknown's avatar
unknown committed
20
#include <time.h>
unknown's avatar
unknown committed
21
#include <assert.h>
unknown's avatar
unknown committed
22
#include "log_event.h"
unknown's avatar
unknown committed
23

24
#define BIN_LOG_HEADER_SIZE	4
unknown's avatar
unknown committed
25
#define PROBE_HEADER_LEN	(EVENT_LEN_OFFSET+4)
26

27

unknown's avatar
unknown committed
28 29
#define CLIENT_CAPABILITIES	(CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_LOCAL_FILES)

unknown's avatar
unknown committed
30
char server_version[SERVER_VERSION_LENGTH];
31
ulong server_id = 0;
unknown's avatar
unknown committed
32 33 34 35

// needed by net_serv.c
ulong bytes_sent = 0L, bytes_received = 0L;
ulong mysqld_net_retry_count = 10L;
36
ulong open_files_limit;
unknown's avatar
unknown committed
37
uint test_flags = 0; 
38
static uint opt_protocol= 0;
unknown's avatar
unknown committed
39
static FILE *result_file;
unknown's avatar
unknown committed
40 41 42 43

#ifndef DBUG_OFF
static const char* default_dbug_option = "d:t:o,/tmp/mysqlbinlog.trace";
#endif
unknown's avatar
unknown committed
44
static const char *load_default_groups[]= { "mysqlbinlog","client",0 };
unknown's avatar
unknown committed
45

unknown's avatar
unknown committed
46
void sql_print_error(const char *format, ...);
unknown's avatar
unknown committed
47

48
static bool one_database = 0;
49 50
static const char* database= 0;
static my_bool force_opt= 0, short_form= 0, remote_opt= 0;
51
static ulonglong offset = 0;
52
static const char* host = 0;
unknown's avatar
unknown committed
53
static int port = MYSQL_PORT;
54
static const char* sock= 0;
55
static const char* user = 0;
56
static char* pass = 0;
57
static ulonglong position = 0;
unknown's avatar
unknown committed
58 59
static short binlog_flags = 0; 
static MYSQL* mysql = NULL;
60 61
static const char* dirname_for_local_load= 0;

unknown's avatar
unknown committed
62 63 64 65
static int dump_local_log_entries(const char* logname);
static int dump_remote_log_entries(const char* logname);
static int dump_log_entries(const char* logname);
static int dump_remote_file(NET* net, const char* fname);
unknown's avatar
unknown committed
66 67 68
static void die(const char* fmt, ...);
static MYSQL* safe_connect();

unknown's avatar
unknown committed
69

unknown's avatar
unknown committed
70 71
class Load_log_processor
{
72
  char target_dir_name[FN_REFLEN];
73 74 75
  int target_dir_name_len;
  DYNAMIC_ARRAY file_names;

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
  /*
    Looking for new uniquie filename that doesn't exist yet by 
    adding postfix -%x

    SYNOPSIS 
       create_unique_file()
       
       filename       buffer for filename
       file_name_end  tail of buffer that should be changed
                      should point to a memory enough to printf("-%x",..)

    RETURN VALUES
      values less than 0      - can't find new filename
      values great or equal 0 - created file with found filename
  */
  File create_unique_file(char *filename, char *file_name_end)
92
    {
93 94 95 96 97 98 99 100 101 102
      File res;
      /* If we have to try more than 1000 times, something is seriously wrong */
      for (uint version= 0; version<1000; version++)
      {
	sprintf(file_name_end,"-%x",version);
	if ((res= my_create(filename,0,
			    O_CREAT|O_EXCL|O_BINARY|O_WRONLY,MYF(0)))!=-1)
	  return res;
      }
      return -1;
103 104 105
    }

public:
106
  Load_log_processor() {}
107
  ~Load_log_processor()
108 109 110 111 112 113 114 115 116 117
  {
    destroy();
    delete_dynamic(&file_names);
  }

  int init()
  {
    return init_dynamic_array(&file_names,sizeof(Create_file_log_event*),
			      100,100 CALLER_INFO);
  }
118

unknown's avatar
unknown committed
119
  void init_by_dir_name(const char *dir)
120
    {
unknown's avatar
unknown committed
121 122
      target_dir_name_len= (convert_dirname(target_dir_name, dir, NullS) -
			    target_dir_name);
123 124 125
    }
  void init_by_cur_dir()
    {
126 127 128
      if (my_getwd(target_dir_name,sizeof(target_dir_name),MYF(MY_WME)))
	exit(1);
      target_dir_name_len= strlen(target_dir_name);
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
    }
  void destroy()
    {
      Create_file_log_event **ptr= (Create_file_log_event**)file_names.buffer;
      Create_file_log_event **end= ptr + file_names.elements;
      for (; ptr<end; ptr++)
      {
	if (*ptr)
	{
	  my_free((char*)(*ptr)->fname,MYF(MY_WME));
	  delete *ptr;
	  *ptr= 0;
	}
      }
    }
  Create_file_log_event *grab_event(uint file_id)
    {
146 147
      if (file_id >= file_names.elements)
        return 0;
148 149 150 151 152 153
      Create_file_log_event **ptr= 
	(Create_file_log_event**)file_names.buffer + file_id;
      Create_file_log_event *res= *ptr;
      *ptr= 0;
      return res;
    }
154
  int process(Create_file_log_event *ce);
unknown's avatar
unknown committed
155
  int process(Append_block_log_event *ae);
156 157 158
  File prepare_new_file_for_old_format(Load_log_event *le, char *filename);
  int load_old_format_file(NET* net, const char *server_fname,
			   uint server_fname_len, File file);
unknown's avatar
unknown committed
159 160
};

unknown's avatar
unknown committed
161 162


163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
File Load_log_processor::prepare_new_file_for_old_format(Load_log_event *le,
							 char *filename)
{
  uint len;
  char *tail;
  File file;
  
  fn_format(filename, le->fname, target_dir_name, "", 1);
  len= strlen(filename);
  tail= filename + len;
  
  if ((file= create_unique_file(filename,tail)) < 0)
  {
    sql_print_error("Could not construct local filename %s",filename);
    return -1;
  }
  
  le->set_fname_outside_temp_buf(filename,len+strlen(tail));
  
  return file;
}
unknown's avatar
unknown committed
184

unknown's avatar
unknown committed
185

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
int Load_log_processor::load_old_format_file(NET* net, const char*server_fname,
					     uint server_fname_len, File file)
{
  char buf[FN_REFLEN+1];
  buf[0] = 0;
  memcpy(buf + 1, server_fname, server_fname_len + 1);
  if (my_net_write(net, buf, server_fname_len +2) || net_flush(net))
  {
    sql_print_error("Failed  requesting the remote dump of %s", server_fname);
    return -1;
  }
  
  for (;;)
  {
    uint packet_len = my_net_read(net);
    if (packet_len == 0)
202
    {
203
      if (my_net_write(net, "", 0) || net_flush(net))
204
      {
205 206
	sql_print_error("Failed sending the ack packet");
	return -1;
207
      }
208 209 210 211 212 213
      /*
	we just need to send something, as the server will read but
	not examine the packet - this is because mysql_load() sends 
	an OK when it is done
      */
      break;
214
    }
215 216 217 218 219 220 221 222 223 224 225 226 227
    else if (packet_len == packet_error)
    {
      sql_print_error("Failed reading a packet during the dump of %s ", 
		      server_fname);
      return -1;
    }
    
    if (my_write(file, (byte*) net->read_pos, packet_len,MYF(MY_WME|MY_NABP)))
      return -1;
  }
  
  return 0;
}
228

unknown's avatar
unknown committed
229

230
int Load_log_processor::process(Create_file_log_event *ce)
unknown's avatar
unknown committed
231 232 233 234
{
  const char *bname= ce->fname+dirname_length(ce->fname);
  uint blen= ce->fname_len - (bname-ce->fname);
  uint full_len= target_dir_name_len + blen + 9 + 9 + 1;
unknown's avatar
unknown committed
235
  int error= 0;
236 237
  char *fname, *ptr;
  File file;
unknown's avatar
unknown committed
238
  DBUG_ENTER("Load_log_processor::process");
unknown's avatar
unknown committed
239

unknown's avatar
unknown committed
240
  if (set_dynamic(&file_names,(gptr)&ce,ce->file_id))
unknown's avatar
unknown committed
241
  {
242 243
    sql_print_error("Could not construct local filename %s%s",
		    target_dir_name,bname);
unknown's avatar
unknown committed
244
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
245
  }
unknown's avatar
unknown committed
246
  if (!(fname= my_malloc(full_len,MYF(MY_WME))))
unknown's avatar
unknown committed
247
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
248

249 250
  memcpy(fname, target_dir_name, target_dir_name_len);
  ptr= fname + target_dir_name_len;
unknown's avatar
unknown committed
251 252 253 254
  memcpy(ptr,bname,blen);
  ptr+= blen;
  ptr+= my_sprintf(ptr,(ptr,"-%x",ce->file_id));

255 256 257 258
  if ((file= create_unique_file(fname,ptr)) < 0)
  {
    sql_print_error("Could not construct local filename %s%s",
		    target_dir_name,bname);
unknown's avatar
unknown committed
259
    DBUG_RETURN(-1);
260 261
  }
  ce->set_fname_outside_temp_buf(fname,strlen(fname));
unknown's avatar
unknown committed
262

unknown's avatar
unknown committed
263 264
  if (my_write(file,(byte*) ce->block,ce->block_len,MYF(MY_WME|MY_NABP)))
    error= -1;
unknown's avatar
unknown committed
265
  if (my_close(file, MYF(MY_WME)))
unknown's avatar
unknown committed
266
    error= -1;
unknown's avatar
unknown committed
267
  DBUG_RETURN(error);
268 269
}

unknown's avatar
unknown committed
270 271 272

int Load_log_processor::process(Append_block_log_event *ae)
{
unknown's avatar
unknown committed
273
  DBUG_ENTER("Load_log_processor::process");
unknown's avatar
unknown committed
274 275 276 277
  Create_file_log_event* ce= ((ae->file_id < file_names.elements) ?
			      *((Create_file_log_event**)file_names.buffer +
				ae->file_id) :
			      0);
unknown's avatar
unknown committed
278

unknown's avatar
unknown committed
279 280 281 282 283 284
  if (ce)
  {
    File file;
    int error= 0;
    if (((file= my_open(ce->fname,
			O_APPEND|O_BINARY|O_WRONLY,MYF(MY_WME))) < 0))
unknown's avatar
unknown committed
285
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
286 287 288 289
    if (my_write(file,(byte*)ae->block,ae->block_len,MYF(MY_WME|MY_NABP)))
      error= -1;
    if (my_close(file,MYF(MY_WME)))
      error= -1;
unknown's avatar
unknown committed
290
    DBUG_RETURN(error);
unknown's avatar
unknown committed
291 292 293 294 295 296
  }

  /*
    There is no Create_file event (a bad binlog or a big
    --position). Assuming it's a big --position, we just do nothing and
    print a warning.
unknown's avatar
unknown committed
297
  */
unknown's avatar
unknown committed
298 299
  fprintf(stderr,"Warning: ignoring Append_block as there is no \
Create_file event for file_id: %u\n",ae->file_id);
unknown's avatar
unknown committed
300
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
301 302 303
}


304 305
Load_log_processor load_processor;

unknown's avatar
unknown committed
306 307 308

int process_event(ulonglong *rec_count, char *last_db, Log_event *ev, 
		  my_off_t pos, int old_format)
309 310
{
  char ll_buff[21];
unknown's avatar
unknown committed
311 312
  DBUG_ENTER("process_event");

313
  if ((*rec_count) >= offset)
unknown's avatar
unknown committed
314
  {
315 316 317 318 319 320 321 322 323
    if (!short_form)
      fprintf(result_file, "# at %s\n",llstr(pos,ll_buff));
    
    switch (ev->get_type_code()) {
    case QUERY_EVENT:
      if (one_database)
      {
	const char * log_dbname = ((Query_log_event*)ev)->db;
	if ((log_dbname != NULL) && (strcmp(log_dbname, database)))
unknown's avatar
unknown committed
324
	  goto end;
325 326
      }
      ev->print(result_file, short_form, last_db);
unknown's avatar
unknown committed
327
      break;
328
    case CREATE_FILE_EVENT:
unknown's avatar
unknown committed
329
    {
330 331 332 333 334 335 336 337 338 339 340
      Create_file_log_event* ce= (Create_file_log_event*)ev;
      if (one_database)
      {
	/*
	  We test if this event has to be ignored. If yes, we don't save 
	      this event; this will have the good side-effect of ignoring all 
	      related Append_block and Exec_load.
	      Note that Load event from 3.23 is not tested.
	*/
	const char * log_dbname = ce->db;            
	if ((log_dbname != NULL) && (strcmp(log_dbname, database)))
unknown's avatar
unknown committed
341
	  goto end;				// Next event
342 343 344 345 346 347 348 349
      }
      /*
	We print the event, but with a leading '#': this is just to inform 
	the user of the original command; the command we want to execute 
	will be a derivation of this original command (we will change the 
	filename and use LOCAL), prepared in the 'case EXEC_LOAD_EVENT' 
	below.
      */
350
      ce->print(result_file, short_form, last_db, TRUE);
351 352
      if (!old_format)
      {
unknown's avatar
unknown committed
353 354
	if (load_processor.process(ce))
	  break;				// Error
355 356 357 358 359 360
	ev= 0;
      }
      break;
    }
    case APPEND_BLOCK_EVENT:
      ev->print(result_file, short_form, last_db);
unknown's avatar
unknown committed
361 362
      if (load_processor.process((Append_block_log_event*) ev))
	break;					// Error
363 364 365 366 367 368 369 370 371 372 373 374 375
      break;
    case EXEC_LOAD_EVENT:
    {
      ev->print(result_file, short_form, last_db);
      Execute_load_log_event *exv= (Execute_load_log_event*)ev;
      Create_file_log_event *ce= load_processor.grab_event(exv->file_id);
      /*
	if ce is 0, it probably means that we have not seen the Create_file
	event (a bad binlog, or most probably --position is after the
	Create_file event). Print a warning comment.
      */
      if (ce)
      {
376
	ce->print(result_file, short_form, last_db, TRUE);
377 378 379 380 381 382 383 384 385 386
	my_free((char*)ce->fname,MYF(MY_WME));
	delete ce;
      }
      else
	fprintf(stderr,"Warning: ignoring Exec_load as there is no \
Create_file event for file_id: %u\n",exv->file_id);
      break;
    }
    default:
      ev->print(result_file, short_form, last_db);
unknown's avatar
unknown committed
387 388
    }
  }
unknown's avatar
unknown committed
389 390

end:
391 392 393
  (*rec_count)++;
  if (ev)
    delete ev;
unknown's avatar
unknown committed
394
  DBUG_RETURN(0);
unknown's avatar
unknown committed
395 396 397
}


398 399 400 401 402 403
static struct my_option my_long_options[] =
{
#ifndef DBUG_OFF
  {"debug", '#', "Output debug log.", (gptr*) &default_dbug_option,
   (gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
404
  {"database", 'd', "List entries for just this database (local log only).",
405 406
   (gptr*) &database, (gptr*) &database, 0, GET_STR_ALLOC, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
407
  {"force-read", 'f', "Force reading unknown binlog events.",
408 409
   (gptr*) &force_opt, (gptr*) &force_opt, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
410
  {"help", '?', "Display this help and exit.",
411
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
412
  {"host", 'h', "Get the binlog from server.", (gptr*) &host, (gptr*) &host,
413
   0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
414
  {"offset", 'o', "Skip the first N entries.", (gptr*) &offset, (gptr*) &offset,
415
   0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
416
  {"password", 'p', "Password to connect to remote server.",
417
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
418
  {"port", 'P', "Use port to connect to the remote server.",
419 420
   (gptr*) &port, (gptr*) &port, 0, GET_INT, REQUIRED_ARG, MYSQL_PORT, 0, 0,
   0, 0, 0},
421
  {"position", 'j', "Start reading the binlog at position N.",
422 423
   (gptr*) &position, (gptr*) &position, 0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0,
   0, 0},
424 425 426 427
  {"protocol", OPT_MYSQL_PROTOCOL,
   "The protocol of connection (tcp,socket,pipe,memory).",
   0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

428
  {"result-file", 'r', "Direct output to a given file.", 0, 0, 0, GET_STR,
429
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
430
  {"read-from-remote-server", 'R', "Read binary logs from a MySQL server",
431 432
   (gptr*) &remote_opt, (gptr*) &remote_opt, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
433 434 435 436
  {"open_files_limit", OPT_OPEN_FILES_LIMIT,
   "Used to reserve file descriptors for usage by this program",
   (gptr*) &open_files_limit, (gptr*) &open_files_limit, 0, GET_ULONG,
   REQUIRED_ARG, MY_NFILE, 8, OS_FILE_LIMIT, 0, 1, 0},
437
  {"short-form", 's', "Just show the queries, no extra info.",
438 439
   (gptr*) &short_form, (gptr*) &short_form, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
unknown's avatar
unknown committed
440
  {"socket", 'S', "Socket file to use for connection.",
441
   (gptr*) &sock, (gptr*) &sock, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 
unknown's avatar
unknown committed
442
   0, 0},
443
  {"user", 'u', "Connect to the remote server as username.",
444 445
   (gptr*) &user, (gptr*) &user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0,
   0, 0},
446 447
  {"local-load", 'l', "Prepare files for local load in directory.",
   (gptr*) &dirname_for_local_load, (gptr*) &dirname_for_local_load, 0,
448
   GET_STR_ALLOC, OPT_ARG, 0, 0, 0, 0, 0, 0},
449 450 451 452 453
  {"version", 'V', "Print version and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
   0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};

unknown's avatar
unknown committed
454 455 456

void sql_print_error(const char *format,...)
{
unknown's avatar
unknown committed
457 458 459 460 461 462
  va_list args;
  va_start(args, format);
  fprintf(stderr, "ERROR: ");
  vfprintf(stderr, format, args);
  fprintf(stderr, "\n");
  va_end(args);
unknown's avatar
unknown committed
463
}
unknown's avatar
unknown committed
464

465 466 467
static void cleanup()
{
  my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
468 469 470 471
  my_free((char*) database, MYF(MY_ALLOW_ZERO_PTR));
  my_free((char*) host, MYF(MY_ALLOW_ZERO_PTR));
  my_free((char*) user, MYF(MY_ALLOW_ZERO_PTR));
  my_free((char*) dirname_for_local_load, MYF(MY_ALLOW_ZERO_PTR));
472 473
}

unknown's avatar
unknown committed
474 475 476 477 478 479 480 481
static void die(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  fprintf(stderr, "ERROR: ");
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
482
  cleanup();
unknown's avatar
unknown committed
483
  my_end(0);
unknown's avatar
unknown committed
484 485 486
  exit(1);
}

unknown's avatar
unknown committed
487 488
static void print_version()
{
unknown's avatar
unknown committed
489
  printf("%s Ver 3.0 for %s at %s\n", my_progname, SYSTEM_TYPE, MACHINE_TYPE);
unknown's avatar
unknown committed
490 491 492
}


unknown's avatar
unknown committed
493 494
static void usage()
{
unknown's avatar
unknown committed
495
  print_version();
unknown's avatar
unknown committed
496 497 498
  puts("By Monty and Sasha, for your professional use\n\
This software comes with NO WARRANTY:  This is free software,\n\
and you are welcome to modify and redistribute it under the GPL license\n");
unknown's avatar
unknown committed
499 500

  printf("\
unknown's avatar
unknown committed
501
Dumps a MySQL binary log in a format usable for viewing or for piping to\n\
unknown's avatar
unknown committed
502
the mysql command line client\n\n");
503 504 505
  printf("Usage: %s [options] log-files\n", my_progname);
  my_print_help(my_long_options);
  my_print_variables(my_long_options);
unknown's avatar
unknown committed
506 507
}

508
extern "C" my_bool
509 510 511
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
512
  bool tty_password=0;
513
  switch (optid) {
unknown's avatar
unknown committed
514
#ifndef DBUG_OFF
515 516 517
  case '#':
    DBUG_PUSH(argument ? argument : default_dbug_option);
    break;
unknown's avatar
unknown committed
518
#endif
519 520 521 522
  case 'd':
    one_database = 1;
    break;
  case 'p':
523 524 525 526 527 528 529 530 531 532 533
    if (argument)
    {
      my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
      char *start=argument;
      pass= my_strdup(argument,MYF(MY_FAE));
      while (*argument) *argument++= 'x';		/* Destroy argument */
      if (*start)
        start[1]=0;				/* Cut length of argument */
    }
    else
      tty_password=1;
534 535 536 537 538
    break;
  case 'r':
    if (!(result_file = my_fopen(argument, O_WRONLY | O_BINARY, MYF(MY_WME))))
      exit(1);
    break;
539 540
  case 'R':
    remote_opt= 1;
541
    break;
542 543 544 545 546 547 548 549 550 551 552
  case OPT_MYSQL_PROTOCOL:
  {
    if ((opt_protocol= find_type(argument, &sql_protocol_typelib,0)) ==
	~(ulong) 0)
    {
      fprintf(stderr, "Unknown option to protocol: %s\n", argument);
      exit(1);
    }
    break;
  }
  break;
553 554 555 556 557 558
  case 'V':
    print_version();
    exit(0);
  case '?':
    usage();
    exit(0);
unknown's avatar
unknown committed
559
  }
560 561 562
  if (tty_password)
    pass= get_tty_password(NullS);

563 564 565
  return 0;
}

unknown's avatar
unknown committed
566

567 568 569
static int parse_args(int *argc, char*** argv)
{
  int ho_error;
unknown's avatar
unknown committed
570

571
  result_file = stdout;
unknown's avatar
unknown committed
572
  load_defaults("my",load_default_groups,argc,argv);
573
  if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
574 575
    exit(ho_error);

unknown's avatar
unknown committed
576 577 578 579 580
  return 0;
}

static MYSQL* safe_connect()
{
unknown's avatar
unknown committed
581
  MYSQL *local_mysql = mysql_init(NULL);
582
  if (!local_mysql)
unknown's avatar
unknown committed
583
    die("Failed on mysql_init");
unknown's avatar
unknown committed
584

585 586
  if (opt_protocol)
    mysql_options(local_mysql, MYSQL_OPT_PROTOCOL, (char*) &opt_protocol);
unknown's avatar
unknown committed
587
  if (!mysql_real_connect(local_mysql, host, user, pass, 0, port, sock, 0))
unknown's avatar
unknown committed
588
    die("failed on connect: %s", mysql_error(local_mysql));
unknown's avatar
unknown committed
589 590 591 592

  return local_mysql;
}

unknown's avatar
unknown committed
593 594

static int dump_log_entries(const char* logname)
unknown's avatar
unknown committed
595
{
596
  if (remote_opt)
unknown's avatar
unknown committed
597 598
    return dump_remote_log_entries(logname);
  return dump_local_log_entries(logname);  
unknown's avatar
unknown committed
599 600
}

unknown's avatar
unknown committed
601

602 603 604 605 606 607
static int check_master_version(MYSQL* mysql)
{
  MYSQL_RES* res = 0;
  MYSQL_ROW row;
  const char* version;
  int old_format = 0;
unknown's avatar
unknown committed
608

609 610
  if (mysql_query(mysql, "SELECT VERSION()") ||
      !(res = mysql_store_result(mysql)))
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
  {
    mysql_close(mysql);
    die("Error checking master version: %s",
		    mysql_error(mysql));
  }
  if (!(row = mysql_fetch_row(res)))
  {
    mysql_free_result(res);
    mysql_close(mysql);
    die("Master returned no rows for SELECT VERSION()");
    return 1;
  }
  if (!(version = row[0]))
  {
    mysql_free_result(res);
    mysql_close(mysql);
    die("Master reported NULL for the version");
  }
unknown's avatar
unknown committed
629

630
  switch (*version) {
631 632 633 634
  case '3':
    old_format = 1;
    break;
  case '4':
635
  case '5':
636 637 638 639 640 641 642 643 644 645 646 647
    old_format = 0;
    break;
  default:
    sql_print_error("Master reported unrecognized MySQL version '%s'",
		    version);
    mysql_free_result(res);
    mysql_close(mysql);
    return 1;
  }
  mysql_free_result(res);
  return old_format;
}
unknown's avatar
unknown committed
648

649

unknown's avatar
unknown committed
650
static int dump_remote_log_entries(const char* logname)
unknown's avatar
unknown committed
651 652
{
  char buf[128];
653
  char last_db[FN_REFLEN+1] = "";
unknown's avatar
unknown committed
654 655
  uint len;
  NET* net = &mysql->net;
656
  int old_format;
unknown's avatar
unknown committed
657 658
  DBUG_ENTER("dump_remote_log_entries");

659
  old_format = check_master_version(mysql);
unknown's avatar
unknown committed
660

661 662 663
  if (!position)
    position = BIN_LOG_HEADER_SIZE; // protect the innocent from spam
  if (position < BIN_LOG_HEADER_SIZE)
664
  {
665
    position = BIN_LOG_HEADER_SIZE;
unknown's avatar
unknown committed
666
    // warn the user
667
    sql_print_error("Warning: The position in the binary log can't be less than %d.\nStarting from position %d\n", BIN_LOG_HEADER_SIZE, BIN_LOG_HEADER_SIZE);
668
  }
unknown's avatar
unknown committed
669
  int4store(buf, position);
670
  int2store(buf + BIN_LOG_HEADER_SIZE, binlog_flags);
unknown's avatar
unknown committed
671
  len = (uint) strlen(logname);
672 673
  int4store(buf + 6, 0);
  memcpy(buf + 10, logname,len);
674
  if (simple_command(mysql, COM_BINLOG_DUMP, buf, len + 10, 1))
unknown's avatar
unknown committed
675 676
  {
    fprintf(stderr,"Got fatal error sending the log dump command\n");
unknown's avatar
unknown committed
677
    DBUG_RETURN(1);
unknown's avatar
unknown committed
678
  }
unknown's avatar
unknown committed
679

680 681 682
  my_off_t old_off= 0;  
  ulonglong rec_count= 0;
  char fname[FN_REFLEN+1];
unknown's avatar
unknown committed
683

684
  for (;;)
unknown's avatar
unknown committed
685
  {
686
    const char *error;
unknown's avatar
unknown committed
687
    len = net_safe_read(mysql);
unknown's avatar
unknown committed
688
    if (len == packet_error)
unknown's avatar
unknown committed
689 690 691
    {
      fprintf(stderr, "Got error reading packet from server: %s\n",
	      mysql_error(mysql));
unknown's avatar
unknown committed
692
      DBUG_RETURN(1);
unknown's avatar
unknown committed
693
    }
unknown's avatar
unknown committed
694
    if (len < 8 && net->read_pos[0] == 254)
unknown's avatar
unknown committed
695 696 697
      break; // end of data
    DBUG_PRINT("info",( "len= %u, net->read_pos[5] = %d\n",
			len, net->read_pos[5]));
698 699
    Log_event *ev = Log_event::read_log_event((const char*) net->read_pos + 1 ,
					      len - 1, &error, old_format);
700
    if (!ev)
unknown's avatar
unknown committed
701
    {
unknown's avatar
unknown committed
702
      fprintf(stderr, "Could not construct log event object\n");
unknown's avatar
unknown committed
703
      DBUG_RETURN(1);
704
    }   
unknown's avatar
unknown committed
705 706 707 708 709

    Log_event_type type= ev->get_type_code();
    if (!old_format || ( type != LOAD_EVENT && type != CREATE_FILE_EVENT))
    {
      if (process_event(&rec_count,last_db,ev,old_off,old_format))
unknown's avatar
unknown committed
710
	DBUG_RETURN(1);
unknown's avatar
unknown committed
711 712
    }
    else
713
    {
unknown's avatar
unknown committed
714 715 716 717 718 719
      Load_log_event *le= (Load_log_event*)ev;
      const char *old_fname= le->fname;
      uint old_len= le->fname_len;
      File file;

      if ((file= load_processor.prepare_new_file_for_old_format(le,fname)) < 0)
unknown's avatar
unknown committed
720 721
	DBUG_RETURN(1);

unknown's avatar
unknown committed
722
      if (process_event(&rec_count,last_db,ev,old_off,old_format))
723
      {
unknown's avatar
unknown committed
724
	my_close(file,MYF(MY_WME));
unknown's avatar
unknown committed
725
	DBUG_RETURN(1);
726
      }
unknown's avatar
unknown committed
727
      if (load_processor.load_old_format_file(net,old_fname,old_len,file))
728
      {
unknown's avatar
unknown committed
729
	my_close(file,MYF(MY_WME));
unknown's avatar
unknown committed
730
	DBUG_RETURN(1);
731
      }
unknown's avatar
unknown committed
732
      my_close(file,MYF(MY_WME));
unknown's avatar
unknown committed
733
    }
734 735
    
    /*
unknown's avatar
unknown committed
736 737
      Let's adjust offset for remote log as for local log to produce 
      similar text..
738 739 740
    */
    if (old_off)
      old_off+= len-1;
unknown's avatar
unknown committed
741
    else
742
      old_off= BIN_LOG_HEADER_SIZE;
unknown's avatar
unknown committed
743
  }
unknown's avatar
unknown committed
744
  DBUG_RETURN(0);
unknown's avatar
unknown committed
745 746
}

747

unknown's avatar
unknown committed
748
static int check_header(IO_CACHE* file)
749
{
unknown's avatar
unknown committed
750
  byte header[BIN_LOG_HEADER_SIZE];
unknown's avatar
unknown committed
751
  byte buf[PROBE_HEADER_LEN];
752
  int old_format=0;
unknown's avatar
unknown committed
753
  DBUG_ENTER("check_header");
unknown's avatar
unknown committed
754

755 756
  my_off_t pos = my_b_tell(file);
  my_b_seek(file, (my_off_t)0);
unknown's avatar
unknown committed
757 758 759 760 761
  if (my_b_read(file, header, sizeof(header)))
    die("Failed reading header;  Probably an empty file");
  if (memcmp(header, BINLOG_MAGIC, sizeof(header)))
    die("File is not a binary log file");
  if (!my_b_read(file, buf, sizeof(buf)))
762
  {
unknown's avatar
unknown committed
763 764 765
    if (buf[4] == START_EVENT)
    {
      uint event_len;
766 767
      event_len = uint4korr(buf + EVENT_LEN_OFFSET);
      old_format = (event_len < (LOG_EVENT_HEADER_LEN + START_HEADER_LEN));
unknown's avatar
unknown committed
768
    }
769 770
  }
  my_b_seek(file, pos);
unknown's avatar
unknown committed
771
  DBUG_RETURN(old_format);
772 773
}

unknown's avatar
unknown committed
774

unknown's avatar
unknown committed
775
static int dump_local_log_entries(const char* logname)
unknown's avatar
unknown committed
776
{
unknown's avatar
unknown committed
777
  File fd = -1;
778
  IO_CACHE cache,*file= &cache;
779
  ulonglong rec_count = 0;
780 781
  char last_db[FN_REFLEN+1];
  byte tmp_buff[BIN_LOG_HEADER_SIZE];
782
  bool old_format = 0;
unknown's avatar
unknown committed
783
  int error= 0;
784

unknown's avatar
unknown committed
785
  last_db[0]= 0;
unknown's avatar
unknown committed
786

787 788 789
  if (logname && logname[0] != '-')
  {
    if ((fd = my_open(logname, O_RDONLY | O_BINARY, MYF(MY_WME))) < 0)
unknown's avatar
unknown committed
790
      return 1;
791 792
    if (init_io_cache(file, fd, 0, READ_CACHE, (my_off_t) position, 0,
		      MYF(MY_WME | MY_NABP)))
unknown's avatar
unknown committed
793 794
    {
      my_close(fd, MYF(MY_WME));
795
      exit(1);
unknown's avatar
unknown committed
796
    }
797
    old_format = check_header(file);
798 799 800
  }
  else
  {
801
    if (init_io_cache(file, fileno(result_file), 0, READ_CACHE, (my_off_t) 0,
802
		      0, MYF(MY_WME | MY_NABP | MY_DONT_CHECK_FILESIZE)))
unknown's avatar
unknown committed
803
      return 1;
804
    old_format = check_header(file);
805 806 807
    if (position)
    {
      /* skip 'position' characters from stdout */
unknown's avatar
unknown committed
808
      byte buff[IO_SIZE];
809
      my_off_t length,tmp;
810
      for (length= (my_off_t) position ; length > 0 ; length-=tmp)
811 812
      {
	tmp=min(length,sizeof(buff));
813
	if (my_b_read(file, buff, (uint) tmp))
unknown's avatar
unknown committed
814 815 816 817
	{
	  error= 1;
	  goto end;
	}
818 819 820 821 822 823 824
      }
    }
    file->pos_in_file=position;
    file->seek_not_done=0;
  }

  if (!position)
unknown's avatar
unknown committed
825 826 827 828 829 830 831 832 833
  {
    // Skip header
    if (my_b_read(file, tmp_buff, BIN_LOG_HEADER_SIZE))
    {
      error= 1;
      goto end;
    }
  }

834
  for (;;)
835
  {
836
    char llbuff[21];
unknown's avatar
unknown committed
837 838
    my_off_t old_off = my_b_tell(file);

839
    Log_event* ev = Log_event::read_log_event(file, old_format);
840 841 842
    if (!ev)
    {
      if (file->error)
unknown's avatar
unknown committed
843 844 845 846 847 848 849
      {
	fprintf(stderr,
		"Could not read entry at offset %s:"
		"Error in log format or read error\n",
		llstr(old_off,llbuff));
	error= 1;
      }
850
      // file->error == 0 means EOF, that's OK, we break in this case
851 852
      break;
    }
unknown's avatar
unknown committed
853
    if (process_event(&rec_count,last_db,ev,old_off,false))
unknown's avatar
unknown committed
854
    {
unknown's avatar
unknown committed
855 856
      error= 1;
      break;
unknown's avatar
unknown committed
857
    }
858
  }
unknown's avatar
unknown committed
859 860

end:
861
  if (fd >= 0)
862
    my_close(fd, MYF(MY_WME));
863
  end_io_cache(file);
unknown's avatar
unknown committed
864
  return error;
unknown's avatar
unknown committed
865 866
}

867

unknown's avatar
unknown committed
868 869
int main(int argc, char** argv)
{
unknown's avatar
unknown committed
870
  static char **defaults_argv;
unknown's avatar
unknown committed
871
  int exit_value;
unknown's avatar
unknown committed
872
  MY_INIT(argv[0]);
unknown's avatar
unknown committed
873 874
  DBUG_ENTER("main");
  DBUG_PROCESS(argv[0]);
unknown's avatar
unknown committed
875

unknown's avatar
unknown committed
876
  parse_args(&argc, (char***)&argv);
unknown's avatar
unknown committed
877
  defaults_argv=argv;
unknown's avatar
unknown committed
878

879
  if (!argc)
880 881
  {
    usage();
unknown's avatar
unknown committed
882
    free_defaults(defaults_argv);
unknown's avatar
unknown committed
883
    exit(1);
884
  }
unknown's avatar
unknown committed
885

886
  my_set_max_open_files(open_files_limit);
887
  if (remote_opt)
888
    mysql = safe_connect();
889 890 891 892 893 894 895 896 897 898

  MY_TMPDIR tmpdir;
  tmpdir.list= 0;
  if (!dirname_for_local_load)
  {
    if (init_tmpdir(&tmpdir, 0))
      exit(1);
    dirname_for_local_load= my_tmpdir(&tmpdir);
  }

899 900
  if (load_processor.init())
    exit(1);
901 902
  if (dirname_for_local_load)
    load_processor.init_by_dir_name(dirname_for_local_load);
903 904
  else
    load_processor.init_by_cur_dir();
unknown's avatar
unknown committed
905

unknown's avatar
unknown committed
906
  exit_value= 0;
907
  while (--argc >= 0)
unknown's avatar
unknown committed
908 909 910 911 912 913 914
  {
    if (dump_log_entries(*(argv++)))
    {
      exit_value=1;
      break;
    }
  }
915

916 917
  if (tmpdir.list)
    free_tmpdir(&tmpdir);
918 919
  if (result_file != stdout)
    my_fclose(result_file, MYF(0));
920
  if (remote_opt)
unknown's avatar
unknown committed
921
    mysql_close(mysql);
922
  cleanup();
unknown's avatar
unknown committed
923
  free_defaults(defaults_argv);
924
  my_free_open_file_info();
unknown's avatar
unknown committed
925
  my_end(0);
unknown's avatar
unknown committed
926
  exit(exit_value);
unknown's avatar
unknown committed
927
  DBUG_RETURN(exit_value);			// Keep compilers happy
unknown's avatar
unknown committed
928 929 930 931 932 933 934
}

/*
  We must include this here as it's compiled with different options for
  the server
*/

unknown's avatar
unknown committed
935 936 937
#ifdef __WIN__
#include "log_event.cpp"
#else
unknown's avatar
unknown committed
938
#include "log_event.cc"
unknown's avatar
unknown committed
939
#endif
940 941

FIX_GCC_LINKING_PROBLEM