Merge lp:~vlad-lesin/percona-playback/tcpdump-parsing into lp:percona-playback

[Vlad Lesin]

[lp:~vlad-lesin/percona-playback/tcpdump-parsing]

98. By Vlad Lesin on 2012-06-20

Add pandora_have_libmysqlclient.m4 pandora_have_libpcap.m4 to the project because it shouldn't depend on pandora-build being installed.

99. By Vlad Lesin on 2012-06-20

Free drizzle result in ConnectionState destructor.

100. By Vlad Lesin on 2012-06-20

Fix for memory leak in tcpdump plugin.

101. By Vlad Lesin on 2012-06-20

Don't use all caps in labels.

102. By Vlad Lesin on 2012-06-20

One more memory leak fix. See https://bugs.launchpad.net/drizzle/+bug/1015576.

103. By Vlad Lesin on 2012-06-20

License header is added to dispatcher source.

104. By Vlad Lesin on 2012-07-02

Merge with 91..94 revisions of trunk(use autoreconf, add gettext support, add po to Makefile subdirs)

105. By Vlad Lesin on 2012-07-02

Rename pandora_have_libdrizzle.m4 to pandora_have_libdrizzle-1.0.m4 as it finds libdrizzle-1.0 library

106. By Vlad Lesin on 2012-07-02

Use standard libdrizzle-1.0 instead of modified

107. By Vlad Lesin on 2012-07-02

Avoid compilation errors in 'set drizzle result options' code

=== modified file '.bzrignore'
--- .bzrignore	2011-12-30 01:47:04 +0000
+++ .bzrignore	2012-07-02 18:23:18 +0000
@@ -40,3 +40,14 @@
 percona_playback/test/crashme-slow
 percona_playback/test/sqlbench-transactions-slow
 percona_playback/test/sysbench-slow
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
+percona_playback/test/preserve_query_time
+percona_playback/test/tcpdump_accuracy
+percona_playback/test/tcpdump_fragmented_packet
+percona_playback/test/tcpdump_multiple_connections
+percona_playback/test/tcpdump_stress_test
+percona_playback/test/tcpdump_without_handshake
+tags
 
=== modified file 'Makefile.am'
--- Makefile.am	2012-06-22 05:12:15 +0000
+++ Makefile.am	2012-07-02 18:23:18 +0000
@@ -39,6 +39,11 @@
   percona_playback/test/sqlbench-transactions-slow.log \
   percona_playback/test/sysbench-slow.log \
   percona_playback/test/preserve_query_time.log \
+  percona_playback/test/tcpdump_without_handshake.dump \
+  percona_playback/test/tcpdump_fragmented_packet.dump \
+  percona_playback/test/tcpdump_multiple_connections.dump \
+  percona_playback/test/tcpdump_stress_test.dump \
+  percona_playback/test/tcpdump_accuracy.dump \
   test_run.sh
 
 include config/pandora-plugin.am
@@ -71,9 +76,15 @@
 	$(AM_CXXFLAGS) \
 	-DBUILDING_PERCONA_PLAYBACK
 
+<<<<<<< TREE
 libpercona_playback_la_LIBADD = $(LIBDL_LIBS) $(BOOST_LIBS) $(TBB_LIBS)
 libpercona_playback_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(LIBPERCONA_PLAYBACK_VERSION) $(BOOST_LIBS) $(TBB_LIBS) $(pandora_plugin_libs)
 libpercona_playback_la_DEPENDENCIES = ${noinst_LTLIBRARIES} $(pandora_plugin_libs)
+=======
+libpercona_playback_la_LIBADD = $(LIBDL_LIBS) $(BOOST_LIBS) $(LTLIBTBB)
+libpercona_playback_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(LIBPERCONA_PLAYBACK_VERSION) $(BOOST_LIBS) $(LTLIBTBB) $(pandora_plugin_libs)
+libpercona_playback_la_DEPENDENCIES = ${noinst_LTLIBRARIES} $(pandora_plugin_libs)
+>>>>>>> MERGE-SOURCE
 
 check_PROGRAMS += \
   percona_playback/test/basic \
@@ -82,6 +93,11 @@
   percona_playback/test/sqlbench-transactions-slow \
   percona_playback/test/sysbench-slow \
   percona_playback/test/preserve_query_time \
+  percona_playback/test/tcpdump_without_handshake \
+  percona_playback/test/tcpdump_fragmented_packet \
+  percona_playback/test/tcpdump_multiple_connections \
+  percona_playback/test/tcpdump_stress_test \
+  percona_playback/test/tcpdump_accuracy \
   percona_playback/test/help
 
 percona_playback_test_basic_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
@@ -90,6 +106,11 @@
 percona_playback_test_sqlbench_transactions_slow_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
 percona_playback_test_sysbench_slow_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
 percona_playback_test_preserve_query_time_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
+percona_playback_test_tcpdump_without_handshake_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
+percona_playback_test_tcpdump_fragmented_packet_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
+percona_playback_test_tcpdump_multiple_connections_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
+percona_playback_test_tcpdump_stress_test_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
+percona_playback_test_tcpdump_accuracy_CXXFLAGS= $(AM_CXXFLAGS) -DSRCDIR=\"${srcdir}\"
 
 percona_playback_test_help_SOURCES= percona_playback/test/help.cc
 percona_playback_test_help_LDADD= $(LDADD) $(MYSQL_LIBS)
@@ -112,7 +133,20 @@
 percona_playback_test_preserve_query_time_SOURCES= percona_playback/test/preserve_query_time.cc
 percona_playback_test_preserve_query_time_LDADD= $(LDADD) $(MYSQL_LIBS)
 
-
+percona_playback_test_tcpdump_without_handshake_SOURCES= percona_playback/test/tcpdump_without_handshake.cc
+percona_playback_test_tcpdump_without_handshake_LDADD= $(LDADD) $(MYSQL_LIBS)
+
+percona_playback_test_tcpdump_fragmented_packet_SOURCES= percona_playback/test/tcpdump_fragmented_packet.cc
+percona_playback_test_tcpdump_fragmented_packet_LDADD= $(LDADD) $(MYSQL_LIBS)
+
+percona_playback_test_tcpdump_multiple_connections_SOURCES= percona_playback/test/tcpdump_multiple_connections.cc
+percona_playback_test_tcpdump_multiple_connections_LDADD= $(LDADD) $(MYSQL_LIBS)
+
+percona_playback_test_tcpdump_stress_test_SOURCES= percona_playback/test/tcpdump_stress_test.cc
+percona_playback_test_tcpdump_stress_test_LDADD= $(LDADD) $(MYSQL_LIBS)
+
+percona_playback_test_tcpdump_accuracy_SOURCES= percona_playback/test/tcpdump_accuracy.cc
+percona_playback_test_tcpdump_accuracy_LDADD= $(LDADD) $(MYSQL_LIBS)
 
 #
 # Simple percona_playback application
@@ -120,7 +154,7 @@
 
 bin_PROGRAMS += bin/percona_playback
 bin_percona_playback_SOURCES = bin/percona_playback.cc
-bin_percona_playback_LDADD= $(BOOST_LIBS) $(LDADD) $(TBB_LIBS) $(MYSQL_LIBS) $(pandora_plugin_libs) $(PANDORA_DYNAMIC_LDADDS)
+bin_percona_playback_LDADD= $(BOOST_LIBS) $(LDADD) $(LTLIBTBB) $(MYSQL_LIBS) $(pandora_plugin_libs) $(PANDORA_DYNAMIC_LDADDS)
 
 include docs/include.am
 
 
=== modified file 'configure.ac'
--- configure.ac	2012-06-24 04:28:41 +0000
+++ configure.ac	2012-07-02 18:23:18 +0000
@@ -58,8 +58,13 @@
 
 AC_DEFINE_UNQUOTED([PERCONA_PLAYBACK_MODULE_EXT], ["$acl_cv_shlibext"],
                    [Extension to use for modules.])
+<<<<<<< TREE
 AM_CXXFLAGS="${AM_CXXFLAGS} ${NO_EFF_CXX} ${NO_OLD_STYLE_CAST} ${NO_VISIBILITY}"
 AC_CONFIG_FILES(Makefile dnl po/Makefile.in
+=======
+AM_CXXFLAGS="${NO_EFF_CXX}"
+AC_CONFIG_FILES(Makefile dnl po/Makefile.in
+>>>>>>> MERGE-SOURCE
  percona_playback/version.h dnl
  docs/header.html)
 
 
=== added file 'm4/pandora_have_libdrizzle-1.0.m4'
--- m4/pandora_have_libdrizzle-1.0.m4	1970-01-01 00:00:00 +0000
+++ m4/pandora_have_libdrizzle-1.0.m4	2012-07-02 18:23:18 +0000
@@ -0,0 +1,74 @@
+dnl  Copyright (C) 2009 Sun Microsystems, Inc.
+dnl This file is free software; Sun Microsystems, Inc.
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([_PANDORA_SEARCH_LIBDRIZZLE_1_0],[
+  AC_REQUIRE([AC_LIB_PREFIX])
+
+  dnl --------------------------------------------------------------------
+  dnl  Check for libdrizzle
+  dnl --------------------------------------------------------------------
+
+  AC_ARG_ENABLE([libdrizzle],
+    [AS_HELP_STRING([--disable-libdrizzle],
+      [Build with libdrizzle support @<:@default=on@:>@])],
+    [ac_enable_libdrizzle="$enableval"],
+    [ac_enable_libdrizzle="yes"])
+
+  AS_IF([test "x$ac_enable_libdrizzle" = "xyes"],[
+    AC_LIB_HAVE_LINKFLAGS(drizzle,,[
+      #include <libdrizzle/drizzle_client.h>
+    ],[
+      drizzle_st drizzle;
+      drizzle_version();
+    ])
+  ],[
+    ac_cv_libdrizzle="no"
+  ])
+
+  AS_IF([test "${ac_cv_libdrizzle}" = "no" -a "${ac_enable_libdrizzle}" = "yes"],[
+    PKG_CHECK_MODULES([LIBDRIZZLE], [libdrizzle-1.0], [
+      ac_cv_libdrizzle=yes
+      LTLIBDRIZZLE=${LIBDRIZZLE_LIBS}
+      LIBDRIZZLE=${LIBDRIZZLE_LIBS}
+      CPPFLAGS=${LIBDRIZZLE_CFLAGS} ${CPPFLAGS}
+      HAVE_LIBDRIZZLE="yes"
+      AC_SUBST(HAVE_LIBDRIZZLE)
+      AC_SUBST(LIBDRIZZLE)
+      AC_SUBST(LTLIBDRIZZLE)
+    ],[])
+  ])
+
+  AM_CONDITIONAL(HAVE_LIBDRIZZLE, [test "x${ac_cv_libdrizzle}" = "xyes"])
+])
+
+AC_DEFUN([PANDORA_HAVE_LIBDRIZZLE_1_0],[
+  AC_REQUIRE([_PANDORA_SEARCH_LIBDRIZZLE_1_0])
+])
+
+AC_DEFUN([PANDORA_REQUIRE_LIBDRIZZLE_1_0],[
+  AC_REQUIRE([PANDORA_HAVE_LIBDRIZZLE_1_0])
+  AS_IF([test "x${ac_cv_libdrizzle}" = "xno"],[
+    AC_MSG_ERROR([libdrizzle is required for ${PACKAGE}])
+  ],[
+    dnl We need at least 0.8 on Solaris non-sparc
+    AS_IF([test "$target_cpu" != "sparc" -a "x${TARGET_SOLARIS}" = "xtrue"],[
+      PANDORA_LIBDRIZZLE_RECENT
+    ])
+  ])
+])
+
+AC_DEFUN([PANDORA_LIBDRIZZLE_RECENT],[
+  AC_CACHE_CHECK([if libdrizzle is recent enough],
+    [pandora_cv_libdrizzle_recent],
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#include <libdrizzle/drizzle.h>
+drizzle_con_options_t foo= DRIZZLE_CON_EXPERIMENTAL;
+    ]])],
+    [pandora_cv_libdrizzle_recent=yes],
+    [pandora_cv_libdrizzle_recent=no])])
+  AS_IF([test "$pandora_cv_libdrizzle_recent" = "no"],[
+    AC_MSG_ERROR([Your version of libdrizzle is too old. ${PACKAGE} requires at least version 0.8])
+  ])
+])
 
=== removed file 'm4/pandora_have_libdrizzle.m4'
--- m4/pandora_have_libdrizzle.m4	2012-04-03 05:13:48 +0000
+++ m4/pandora_have_libdrizzle.m4	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-dnl  Copyright (C) 2009 Sun Microsystems, Inc.
-dnl This file is free software; Sun Microsystems, Inc.
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-AC_DEFUN([_PANDORA_SEARCH_LIBDRIZZLE],[
-  AC_REQUIRE([AC_LIB_PREFIX])
-
-  dnl --------------------------------------------------------------------
-  dnl  Check for libdrizzle
-  dnl --------------------------------------------------------------------
-
-  AC_ARG_ENABLE([libdrizzle],
-    [AS_HELP_STRING([--disable-libdrizzle],
-      [Build with libdrizzle support @<:@default=on@:>@])],
-    [ac_enable_libdrizzle="$enableval"],
-    [ac_enable_libdrizzle="yes"])
-
-  AS_IF([test "x$ac_enable_libdrizzle" = "xyes"],[
-    AC_LIB_HAVE_LINKFLAGS(drizzle,,[
-      #include <libdrizzle/drizzle_client.h>
-    ],[
-      drizzle_st drizzle;
-      drizzle_version();
-    ])
-  ],[
-    ac_cv_libdrizzle="no"
-  ])
-  
-  AM_CONDITIONAL(HAVE_LIBDRIZZLE, [test "x${ac_cv_libdrizzle}" = "xyes"])
-])
-
-AC_DEFUN([PANDORA_HAVE_LIBDRIZZLE],[
-  AC_REQUIRE([_PANDORA_SEARCH_LIBDRIZZLE])
-])
-
-AC_DEFUN([PANDORA_REQUIRE_LIBDRIZZLE],[
-  AC_REQUIRE([PANDORA_HAVE_LIBDRIZZLE])
-  AS_IF([test "x${ac_cv_libdrizzle}" = "xno"],[
-    AC_MSG_ERROR([libdrizzle is required for ${PACKAGE}])
-  ],[
-    dnl We need at least 0.8 on Solaris non-sparc
-    AS_IF([test "$target_cpu" != "sparc" -a "x${TARGET_SOLARIS}" = "xtrue"],[
-      PANDORA_LIBDRIZZLE_RECENT
-    ])
-  ])
-])
-
-AC_DEFUN([PANDORA_LIBDRIZZLE_RECENT],[
-  AC_CACHE_CHECK([if libdrizzle is recent enough],
-    [pandora_cv_libdrizzle_recent],
-    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-#include <libdrizzle/drizzle.h>
-drizzle_con_options_t foo= DRIZZLE_CON_EXPERIMENTAL;
-    ]])],
-    [pandora_cv_libdrizzle_recent=yes],
-    [pandora_cv_libdrizzle_recent=no])])
-  AS_IF([test "$pandora_cv_libdrizzle_recent" = "no"],[
-    AC_MSG_ERROR([Your version of libdrizzle is too old. ${PACKAGE} requires at least version 0.8])
-  ])
-])
 
=== added file 'm4/pandora_have_libmysqlclient.m4'
--- m4/pandora_have_libmysqlclient.m4	1970-01-01 00:00:00 +0000
+++ m4/pandora_have_libmysqlclient.m4	2012-07-02 18:23:18 +0000
@@ -0,0 +1,103 @@
+dnl -*- mode: m4; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+dnl vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+dnl
+dnl  Copyright (C) 2010 Monty Taylor
+dnl  This file is free software; Sun Microsystems
+dnl  gives unlimited permission to copy and/or distribute it,
+dnl  with or without modifications, as long as this notice is preserved.
+dnl
+
+AC_DEFUN([PANDORA_WITH_MYSQL],[
+  AC_ARG_WITH([mysql],
+    [AS_HELP_STRING([--with-mysql=PATH],
+        [path to mysql_config binary or mysql prefix dir])], 
+      [with_mysql=$withval],
+      [with_mysql=":"])
+
+  dnl There are three possibilities:
+  dnl   1) nothing is given: we will search for mysql_config in PATH
+  dnl   2) the location of mysql_config is given: we'll use that to determine
+  dnl   3) a directory argument is given: that will be mysql_base
+
+     
+  dnl option 1: nothing, we need to insert something into MYSQL_CONFIG
+  AS_IF([test "x$with_mysql" = "x:"],[
+    AC_CHECK_PROGS(MYSQL_CONFIG,[mysql_config])
+  ],[
+    MYSQL_CONFIG="${with_mysql}"
+  ])
+
+  AC_CACHE_CHECK([for MySQL Base Location],[pandora_cv_mysql_base],[
+
+    dnl option 2: something in MYSQL_CONFIG now, use that to get a base dir
+    AS_IF([test -f "${MYSQL_CONFIG}" -a -x "${MYSQL_CONFIG}"],[
+      pandora_cv_mysql_base=$(dirname $(${MYSQL_CONFIG} --include | sed 's/-I//'))
+      MYSQL_INCLUDES=$(${MYSQL_CONFIG} --include)
+      MYSQL_INCLUDES="$MYSQL_INCLUDES $(echo $MYSQL_INCLUDES|sed -e 's/-I/-isystem /')"
+      MYSQL_LIBS=$(${MYSQL_CONFIG} --libs_r)
+    ],[
+      dnl option 1: a directory
+      AS_IF([test -d $with_mysql],
+            [
+              pandora_cv_mysql_base=$with_mysql
+              IBASE="-I${with_mysql}"
+              MYSQL_CONFIG="${with_mysql}/bin/mysql_config"
+              MYSQL_INCLUDES="$IBASE/include/mysql -isystem $IBASE/include/mysql"
+              MYSQL_LIBS="-L${with_mysql}/lib -L${with_mysql}/lib/mysql -lmysqlclient_r"
+            ],
+            [
+              pandora_cv_mysql_base=""
+      ])
+    ])
+  ])
+    AC_SUBST(MYSQL_CONFIG)
+    AC_SUBST(MYSQL_INCLUDES)
+    AC_SUBST(MYSQL_LIBS)
+])
+
+AC_DEFUN([_PANDORA_SEARCH_LIBMYSQLCLIENT],[
+  AC_REQUIRE([AC_LIB_PREFIX])
+
+  AC_ARG_ENABLE([libmysqlclient],
+    [AS_HELP_STRING([--disable-libmysqlclient],
+      [Build with libmysqlclient support @<:@default=on@:>@])],
+    [ac_enable_libmysqlclient="$enableval"],
+    [ac_enable_libmysqlclient="yes"])
+
+  AS_IF([test "x$ac_enable_libmysqlclient" = "xyes"],[
+    AC_LIB_HAVE_LINKFLAGS(mysqlclient_r,,[
+#include <mysql/mysql.h>
+    ],[
+MYSQL mysql;
+  ])],[
+    ac_cv_libmysqlclient_r="no"
+  ])
+
+  AM_CONDITIONAL(HAVE_LIBMYSQLCLIENT, [test "x${ac_cv_libmysqlclient_r}" = "xyes"])
+
+  AS_IF([test "x$MYSQL_CONFIG" = "xISDIR"],[
+    IBASE="-I${with_mysql}"
+    MYSQL_CONFIG="${with_mysql}/scripts/mysql_config"
+    ADDIFLAGS="$IBASE/include -isystem $IBASE/include"
+    ADDLDFLAGS="-L${with_mysql}/libmysql_r/.libs/ -L${with_mysql}/mysys/.libs -L${with_mysql}/mysys -L${with_mysql}/strings/.libs -L${with_mysql}/strings "
+  ],[
+    MYSQL_INCLUDES=$(${MYSQL_CONFIG} --include)
+    MYSQL_INCLUDES="$MYSQL_INCLUDES $(echo $MYSQL_INCLUDES|sed -e 's/-I/-isystem /')"
+    MYSQL_LIBS=$(${MYSQL_CONFIG} --libs_r)
+  ])
+
+    AC_SUBST(MYSQL_CONFIG)
+    AC_SUBST(MYSQL_INCLUDES)
+    AC_SUBST(MYSQL_LIBS)
+])
+
+AC_DEFUN([PANDORA_HAVE_LIBMYSQLCLIENT],[
+  AC_REQUIRE([_PANDORA_SEARCH_LIBMYSQLCLIENT])
+])
+
+AC_DEFUN([PANDORA_REQUIRE_LIBMYSQLCLIENT],[
+  AC_REQUIRE([PANDORA_HAVE_LIBMYSQLCLIENT])
+  AS_IF([test "x${ac_cv_libmysqlclient_r}" = "xno"],
+      PANDORA_MSG_ERROR([libmysqlclient_r is required for ${PACKAGE}]))
+])
+
 
=== renamed file 'm4/pandora_have_libmysqlclient.m4' => 'm4/pandora_have_libmysqlclient.m4.moved'
=== modified file 'percona_playback/dispatcher.cc'
--- percona_playback/dispatcher.cc	2012-06-22 06:20:44 +0000
+++ percona_playback/dispatcher.cc	2012-07-02 18:23:18 +0000
@@ -1,3 +1,17 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
 #include "percona_playback/dispatcher.h"
 #include "percona_playback/db_thread.h"
 #include "percona_playback/plugin.h"
 
=== modified file 'percona_playback/percona_playback.cc'
--- percona_playback/percona_playback.cc	2012-06-24 04:28:41 +0000
+++ percona_playback/percona_playback.cc	2012-07-02 18:23:18 +0000
@@ -90,18 +90,30 @@
     std::cerr << std::endl;
     std::cerr << options_description << std::endl;
     std::cerr << std::endl;
+<<<<<<< TREE
     std::cerr << _("Bugs: ") << PACKAGE_BUGREPORT << std::endl;
     std::cerr << _("Loaded plugins: ");
     BOOST_FOREACH(const std::string &plugin_name, PluginRegistry::singleton().loaded_plugin_names)
+=======
+    std::cerr << _("Bugs: ") << PACKAGE_BUGREPORT << std::endl;
+    std::cerr << _("Loaded plugins: ");
+    BOOST_FOREACH(const std::string &plugin_name, percona_playback::PluginRegistry::singleton().loaded_plugin_names)
+>>>>>>> MERGE-SOURCE
     {
       std::cerr << plugin_name << " ";
     }
 
     std::cerr << std::endl;
 
+<<<<<<< TREE
     std::cerr << std::endl << _("Loaded DB Plugins: ");
     for(PluginRegistry::DBClientPluginMap::iterator it= PluginRegistry::singleton().dbclient_plugins.begin();
 	it != PluginRegistry::singleton().dbclient_plugins.end();
+=======
+    std::cerr << std::endl << _("Loaded DB Plugins: ");
+    for(percona_playback::PluginRegistry::DBClientPluginMap::iterator it= percona_playback::PluginRegistry::singleton().dbclient_plugins.begin();
+	it != percona_playback::PluginRegistry::singleton().dbclient_plugins.end();
+>>>>>>> MERGE-SOURCE
 	it++)
     {
       std::cerr << it->first << " ";
@@ -110,12 +122,21 @@
     std::cerr << std::endl;
 
     assert(g_dbclient_plugin);
+<<<<<<< TREE
     std::cerr << _("Selected DB Plugin: ") << g_dbclient_plugin->name << std::endl;
 
     std::cerr << std::endl << _("Loaded Input Plugins: ");
 
     BOOST_FOREACH(const PluginRegistry::InputPluginPair &pp,
 		  PluginRegistry::singleton().input_plugins)
+=======
+    std::cerr << _("Selected DB Plugin: ") << g_dbclient_plugin->name << std::endl;
+
+    std::cerr << std::endl << _("Loaded Input Plugins: ");
+
+    BOOST_FOREACH(const percona_playback::PluginRegistry::InputPluginPair &pp,
+		  percona_playback::PluginRegistry::singleton().input_plugins)
+>>>>>>> MERGE-SOURCE
     {
       std::cerr << pp.first << " ";
     }
 
=== modified file 'percona_playback/query_result.h'
--- percona_playback/query_result.h	2012-06-18 23:59:46 +0000
+++ percona_playback/query_result.h	2012-07-02 18:23:18 +0000
@@ -40,6 +40,13 @@
   {
   }
 
+  void clear()
+  {
+    _rows_sent= _rows_examined= 0;
+    _error= _warning_count= 0;
+    _duration= boost::posix_time::time_duration();
+  }
+
   void setRowsSent(const uint64_t &rows) {
     _rows_sent= rows;
   }
 
=== added file 'percona_playback/tcpdump/connection_state.cc'
--- percona_playback/tcpdump/connection_state.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/connection_state.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,325 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+#include <pcap.h>
+#include <iostream>
+#include <libdrizzle/drizzle_server.h>
+#include <libdrizzle/row_client.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "connection_state.h"
+#include "tcpdump_query_entries.h"
+#include "percona_playback/plugin.h"
+
+extern percona_playback::DBClientPlugin *g_dbclient_plugin;
+
+void
+ConnectionState::ProcessMysqlPkts(const u_char      *pkts,
+                                  u_int             pkts_len,
+                                  const timeval     &ts,
+                                  const AddrPort    &addr_port,
+                                  OUT TcpdumpMysqlParserStats  &stats)
+{
+  
+  u_int used_len= 0;
+  struct MysqlPkt *m;
+
+  assert(pkts);
+
+  // If last pkt was fragmented, merge with current pkts   
+  if (fragmented) 
+  {
+    fragmented= false;
+    size_t old_frag_buff_size= frag_buff.size();
+    frag_buff.insert(frag_buff.end(), pkts, pkts + pkts_len);
+    pkts= &frag_buff[0];
+    pkts_len+= old_frag_buff_size;
+  }
+
+  for(;;)
+  {
+    m= (struct MysqlPkt *)pkts; // Packet header
+
+    // Check if pkts > len of pkts actually received (last pkt is fragmented)
+    used_len+= m->full_length();
+
+    if (used_len > pkts_len) {
+      fragmented= true;
+
+      size_t frag_len= m->full_length() - (used_len - pkts_len);
+                       
+      UCharBuffer new_frag_buff(pkts, pkts + frag_len);
+      frag_buff.swap(new_frag_buff);
+      
+      break;
+    }
+
+    if (m->data_length())
+    {
+      UCharBuffer buff(pkts, pkts + m->full_length());
+      std::string query;
+      PktResult retval= ParseMysqlPkt(buff, query);
+      switch(retval)
+      {
+      case PKT_QUERY:
+        if (!query.empty())
+          DispatchQuery(ts, query, addr_port);
+        ++stats.nr_of_parsed_queries;
+        ++stats.nr_of_parsed_packets;
+        break;
+
+      case PKT_RESULT:
+        DispatchResult(ts, addr_port);
+        ++stats.nr_of_parsed_packets;
+        break;
+
+      case PKT_ERROR:
+        ++stats.nr_of_parsing_errors;
+        break;
+
+      default:
+        ++stats.nr_of_parsed_packets;
+      }
+    }
+    
+    pkts += m->full_length(); // Next pkt header
+
+    if (used_len == pkts_len)
+      break;
+
+  }
+
+  if (!fragmented)
+    frag_buff.clear();
+
+}
+
+void
+ConnectionState::ProcessFinishConnection()
+{
+  db_thread->queries.push(QueryEntryPtr(new FinishEntry()));
+}
+
+PktResult
+ConnectionState::ParseMysqlPkt(IN UCharBuffer  &buff,
+                               OUT std::string &query)
+{
+  if (current_origin == CLIENT)
+    return ClientPacket(buff, query);
+  
+  if (current_origin == SERVER && was_query)
+    return ServerPacket(buff);
+
+  return PKT_UNKNOWN;
+}
+
+PktResult
+ConnectionState::ServerPacket(IN UCharBuffer &buff)
+{
+  PktResult retval= PKT_OK;
+
+  drizzle_return_t ret;
+
+  drizzle_con->buffer_ptr= &buff[0];
+  drizzle_con->buffer_size= buff.size();
+
+  /*
+    Check if we should continue parsing result set or
+    we can start a new loop of result parsing.
+  */
+  if (!drizzle_con->result)
+  {
+  /*  
+    If there are not any parsed results then it can be "Ok",
+    "Error" or "Results set header" packets.
+  */
+    last_query_result.clear();
+
+    drizzle_result_st *res= drizzle_result_read(drizzle_con.get(),
+                                                NULL,
+                                                &ret);
+    /* Check if the packet is "Error" packet */
+    if (ret == DRIZZLE_RETURN_ERROR_CODE)
+    {
+      last_query_result.setError(drizzle_result_error_code(res));
+      retval= PKT_RESULT;
+      /*
+        The text representation of error can be got with
+        drizzle_result_error(res)
+      */
+      goto free_and_return;
+    }
+    else if(ret == DRIZZLE_RETURN_OK)
+    {
+      /* Check if the packet is "Ok" packet */
+      if (!drizzle_result_column_count(res))
+      {
+        last_query_result.setRowsSent(drizzle_result_row_count(res));
+        last_query_result.setRowsExamined(drizzle_result_affected_rows(res));
+        last_query_result.setWarningCount(drizzle_result_warning_count(res));
+        retval= PKT_RESULT;
+        goto free_and_return;
+      }
+      /* Else this is "Result set header" packet */
+    }
+    else
+    {
+      std::cerr << "Unknown packet type from server" << std::endl;
+      retval= PKT_ERROR;
+      goto free_and_return;
+    }
+  }
+  /* Parse result set */
+  else
+  {
+    /* "Field" packets */
+    if (eof_count == 0)
+    {
+      drizzle_column_st *column= drizzle_column_read(drizzle_con->result,
+                                                     NULL,
+                                                     &ret);
+      if (ret == DRIZZLE_RETURN_OK)
+      {
+        /* "EOF" packet */
+        if (column == NULL)
+          ++eof_count;
+        retval= PKT_OK;
+      }
+      else
+      {
+        std::cerr << "Parse column error" << std::endl;
+        retval= PKT_ERROR;
+        goto free_and_return;
+      }
+    }
+    /* "Row" packets */
+    else if (eof_count == 1)
+    {
+      uint8_t  old_packet_number= drizzle_con->packet_number;
+      uint64_t row= drizzle_row_read(drizzle_con->result, &ret);
+      if (ret != DRIZZLE_RETURN_OK)
+      {
+        std::cerr << "Error in parsing row" << std::endl;
+        retval= PKT_ERROR;
+        goto free_and_return;
+      }
+      else
+        ++sent_rows_count;
+      /* "EOF" packet */
+      if (!row)
+      {
+        eof_count= 0;
+      
+        drizzle_con->buffer_ptr= &buff[0];
+        drizzle_con->buffer_size= buff.size();
+   
+        drizzle_result_free_all(drizzle_con.get());
+        drizzle_con->packet_number= old_packet_number;
+        drizzle_result_st *res= drizzle_result_read(drizzle_con.get(),
+                                                    NULL,
+                                                    &ret);
+        /*
+          Setting DRIZZLE_RESULT_ALLOCATED in result options
+          helps to avoid memory leak.
+          See https://bugs.launchpad.net/drizzle/+bug/1015576
+        */
+        res->options=
+          (drizzle_result_options_t)
+            ((uint64_t)(res->options) | (uint64_t)DRIZZLE_RESULT_ALLOCATED);
+        last_query_result.setWarningCount(drizzle_result_warning_count(res));
+        /* Don't count the last EOF packet */
+        last_query_result.setRowsSent(sent_rows_count - 1);
+
+        sent_rows_count= 0;
+        retval= PKT_RESULT;
+        goto free_and_return;
+      }
+      else
+        retval= PKT_OK;
+    }
+  }
+
+  return retval;
+
+free_and_return:
+  drizzle_result_free_all(drizzle_con.get());
+  drizzle_con->result= NULL;
+  was_query= false;
+  return retval;
+}
+
+PktResult
+ConnectionState::ClientPacket(IN UCharBuffer   &buff,
+                              OUT std::string   &query)
+{
+  drizzle_command_t command;
+  drizzle_return_t ret;
+  size_t total;
+  uint8_t *data;
+  PktResult result= PKT_UNKNOWN;
+
+  drizzle_con->buffer_ptr= &buff[0];
+  drizzle_con->buffer_size= buff.size();
+  data= (uint8_t *)drizzle_con_command_buffer(drizzle_con.get(),
+                                              &command,
+                                              &total,
+                                              &ret);
+  if (ret == DRIZZLE_RETURN_OK)
+  {
+    switch(command)
+    {
+      case DRIZZLE_COMMAND_QUERY:
+        query.assign((const char *)data);
+        was_query= true;
+        result= PKT_QUERY;
+        break;
+
+      case DRIZZLE_COMMAND_INIT_DB:
+        query.assign("use ");
+        query+= (const char *)data;
+        was_query= true;
+        result= PKT_QUERY;
+        break;
+
+      default:;
+    }
+  }
+
+  free(data);
+  return result;
+}
+
+void
+ConnectionState::DispatchQuery(const timeval        &ts,
+                               const std::string    &query,
+                               const AddrPort       &addr_port)
+{
+  boost::shared_ptr<TcpdumpQueryEntry> 
+    query_entry(new TcpdumpQueryEntry(ts,
+                                      query,
+                                      addr_port));
+  db_thread->queries.push(query_entry);
+}
+
+void
+ConnectionState::DispatchResult(const timeval    &ts,
+                                const AddrPort   &addr_port)
+{
+  boost::shared_ptr<TcpdumpResultEntry> 
+    result_entry(new TcpdumpResultEntry(addr_port, ts, last_query_result));
+  db_thread->queries.push(result_entry);
+}
+
 
=== added file 'percona_playback/tcpdump/connection_state.h'
--- percona_playback/tcpdump/connection_state.h	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/connection_state.h	2012-07-02 18:23:18 +0000
@@ -0,0 +1,186 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#ifndef PERCONA_PLAYBACK_CONNECTION_STATE_H
+#define PERCONA_PLAYBACK_CONNECTION_STATE_H
+
+#include <stdlib.h>
+#include <sys/time.h>
+#include <vector>
+#include <string>
+#include <string.h>
+#include <boost/shared_ptr.hpp>
+#include <libdrizzle/drizzle_client.h>
+
+#include "percona_playback/query_result.h"
+#include "percona_playback/db_thread.h"
+#include "tcpdump_mysql_parser_stats.h"
+
+enum PktResult
+{
+ PKT_QUERY,
+ PKT_RESULT,
+ PKT_OK,
+ PKT_UNKNOWN,
+ PKT_ERROR
+};
+
+#define IN
+#define OUT
+
+#pragma pack(push, 1)
+// Every logical MySQL packet starts w/ this 4 byte header
+struct MysqlPkt {
+  uint16_t  length_low;
+  uint8_t   length_high;
+  uint8_t   id;
+  uint8_t   data[0];
+
+  size_t data_length() const
+  {
+    return (size_t)length_low | ((size_t)length_high << 16);
+  }
+
+  size_t full_length() const
+  {
+    return data_length() + header_size();
+  }
+
+  static size_t header_size()
+  {
+    return offsetof(MysqlPkt, data);
+  }
+};
+#pragma pack(pop)
+
+struct AddrPort
+{
+  AddrPort() : address(0), port(0) {}
+  AddrPort(uint32_t address, uint16_t port) : address(address), port(port) {}
+  uint32_t address;
+  uint16_t port;
+  uint64_t ThreadId() const
+  {
+    return (uint64_t)address | ((uint64_t)port << 32);
+  }
+};
+
+struct LastExecutedQueryInfo
+{
+  std::string   query;
+  QueryResult   result;
+  timeval       begin_pcap_timestamp;
+  timeval       end_pcap_timestamp;
+  timeval       end_timestamp;
+
+  LastExecutedQueryInfo()
+  {
+    memset(&begin_pcap_timestamp, 0, sizeof(begin_pcap_timestamp));
+    memset(&end_pcap_timestamp, 0, sizeof(end_pcap_timestamp));
+    memset(&end_timestamp, 0, sizeof(end_timestamp));
+  }
+};
+
+
+class ConnectionState : public DBThreadState
+
+{
+
+public:
+
+  enum Origin
+  {
+    UNDEF,
+    CLIENT,
+    SERVER
+  };
+
+  ConnectionState() :
+    current_origin(UNDEF),
+    fragmented(false),
+    handshake_from_client(false),
+    was_query(false),
+    eof_count(0),
+    sent_rows_count(0),
+    drizzle(drizzle_create(NULL), drizzle_free),
+    drizzle_con(
+      drizzle_con_add_tcp(drizzle.get(),
+                          NULL,
+                          "localhost",
+                          3306,
+                          "user",
+                          "password",
+                          "db",
+                          (drizzle_con_options_t)
+                            DRIZZLE_CON_MYSQL),
+      drizzle_con_free),
+    db_thread(NULL)
+   {
+     drizzle_con->result= NULL;
+   }
+
+  ~ConnectionState()
+  {
+    drizzle_result_free_all(drizzle_con.get());
+  }
+
+  void ProcessMysqlPkts(const u_char                 *pkts,
+                        u_int                        total_len,
+                        const timeval                &ts,
+                        const AddrPort               &addr_port,
+                        OUT TcpdumpMysqlParserStats  &stats);
+
+  void ProcessFinishConnection();
+
+  void SetCurrentOrigin(Origin o) { current_origin = o; }
+
+  void SetDBThread(DBThread *t) { db_thread= t; }
+  
+  LastExecutedQueryInfo   last_executed_query_info;
+
+private:
+
+  typedef std::vector<unsigned char> UCharBuffer; 
+  
+  PktResult ParseMysqlPkt(IN UCharBuffer &buff, OUT std::string &query);
+
+  PktResult ServerPacket(IN UCharBuffer &buff);
+  PktResult ClientPacket(IN UCharBuffer &buff, OUT std::string &query);
+
+  void DispatchQuery(const timeval      &ts,
+                     const std::string  &query,
+                     const AddrPort     &addr_port);
+
+  void DispatchResult(const timeval     &ts,
+                      const AddrPort    &addr_port);
+
+  Origin            current_origin;
+  bool              fragmented;
+  UCharBuffer       frag_buff;
+  bool              handshake_from_client;
+  bool              was_query;
+  size_t            eof_count;
+  size_t            sent_rows_count;
+
+  boost::shared_ptr<drizzle_st>       drizzle;
+  boost::shared_ptr<drizzle_con_st>   drizzle_con;
+
+  QueryResult       last_query_result;
+
+  DBThread          *db_thread;
+
+};
+
+#endif // PERCONA_PLAYBACK_CONNECTION_STATE_H
 
=== added file 'percona_playback/tcpdump/pcap_packets_parser.cc'
--- percona_playback/tcpdump/pcap_packets_parser.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/pcap_packets_parser.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,134 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+#include "pcap_packets_parser.h"
+#include "sniff_headers.h"
+#include "tcpdump.h"
+
+#include "percona_playback/db_thread.h"
+#include "percona_playback/plugin.h"
+#include "percona_playback/dispatcher.h"
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <iostream>
+#include <boost/foreach.hpp>
+#include <assert.h>
+
+#define SNAP_LEN            16500  // pcap's max capture size
+
+extern percona_playback::DBClientPlugin *g_dbclient_plugin;
+
+void
+PcapPacketsParser::ParsePkt(const struct pcap_pkthdr *header,
+                            const u_char *packet)
+{
+  ConnectionState::Origin     origin= ConnectionState::UNDEF;
+  const struct                sniff_ethernet *ethernet;
+  const struct                sniff_ip *ip;
+  const struct                sniff_tcp *tcp;
+  const uint8_t               *mysql;
+  size_t                      size_ip;
+  size_t                      size_tcp;
+  size_t                      size_mysql;
+
+  assert(header);
+  assert(packet);
+
+  if(header->len > SNAP_LEN) {
+    std::cerr << "Captured packet too large: "
+              << header->len 
+              << " bytes, Max capture packet size: "
+              << SNAP_LEN << " bytes" << std::endl;
+     return;
+  }
+
+  ethernet=     (struct sniff_ethernet*)(packet);
+  ip=           (struct sniff_ip*)(packet + SIZE_ETHERNET);
+  size_ip=      IP_HL(ip) * 4;
+  tcp=          (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
+  size_tcp=     TH_OFF(tcp) * 4;
+  mysql=        (packet + SIZE_ETHERNET + size_ip + size_tcp);
+  size_mysql=   ntohs(ip->ip_len) - size_ip - size_tcp;
+
+
+  AddrPort addr_port;
+
+  if (ntohs(tcp->th_sport) == g_tcpdump_port)
+  {
+    addr_port.address= ip->ip_dst.s_addr;
+    addr_port.port= tcp->th_dport;
+    origin= ConnectionState::SERVER;
+  }
+  else
+  {
+    addr_port.address= ip->ip_src.s_addr;
+    addr_port.port= tcp->th_sport;
+    origin= ConnectionState::CLIENT;
+  }
+
+  /* The connection was closed. */
+  if (size_mysql == 0 &&
+      ((tcp->th_flags & TH_FIN) || (tcp->th_flags & TH_RST)))
+  {
+    g_dispatcher.finish(addr_port.ThreadId());
+    return;
+  }
+
+  /* The mysql packet is too small. It may be due to tcp service packets. */
+  if (size_mysql < MysqlPkt::header_size())
+    return;
+
+  if (!was_first_packet)
+  {
+    gettimeofday(&first_packet_timestamp, 0);
+    first_packet_pcap_timestamp= header->ts;
+    was_first_packet= true;
+  }
+
+  /* If there is no DBThread with such id create it */
+  boost::shared_ptr<DBThreadState>
+    state= g_dispatcher.get_thread_state(addr_port.ThreadId(),
+      boost::bind(&PcapPacketsParser::CreateConnectionState,
+                  this,
+                  _1));
+
+  assert(state.get());
+
+  ((ConnectionState *)state.get())->SetCurrentOrigin(origin);
+  ((ConnectionState *)state.get())->ProcessMysqlPkts(mysql,
+                                                     size_mysql,
+                                                     header->ts,
+                                                     addr_port,
+                                                     stats);
+}
+
+void
+PcapPacketsParser::WaitForUnfinishedTasks()
+{
+  g_dispatcher.finish_all_and_wait();
+}
+
+void
+PcapPacketsParser::CreateConnectionState(DBThread *db_thread)
+{
+  assert(db_thread);
+  boost::shared_ptr<ConnectionState> state(new ConnectionState());
+  state->last_executed_query_info.end_pcap_timestamp=
+    first_packet_pcap_timestamp;
+  state->last_executed_query_info.end_timestamp=
+    first_packet_timestamp;
+  db_thread->set_state(state);
+  state->SetDBThread(db_thread);
+}
 
=== added file 'percona_playback/tcpdump/pcap_packets_parser.h'
--- percona_playback/tcpdump/pcap_packets_parser.h	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/pcap_packets_parser.h	2012-07-02 18:23:18 +0000
@@ -0,0 +1,64 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#ifndef PERCONA_PLAYBACK_PCAP_PACKETS_PARSER_H
+#define PERCONA_PLAYBACK_PCAP_PACKETS_PARSER_H
+
+#include "connection_state.h"
+#include "tcpdump_mysql_parser_stats.h"
+
+#include <pcap.h>
+#include <tbb/concurrent_queue.h>
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+
+class DBThread;
+
+class PcapPacketsParser
+{
+  TcpdumpMysqlParserStats    stats;
+  timeval                    first_packet_timestamp;
+  timeval                    first_packet_pcap_timestamp;
+  bool                       was_first_packet;
+
+public:
+
+  PcapPacketsParser() : was_first_packet(false)
+  {
+    first_packet_timestamp.tv_sec= first_packet_timestamp.tv_usec= 0;
+    first_packet_pcap_timestamp.tv_sec= first_packet_pcap_timestamp.tv_usec= 0;
+  }
+
+  static void Process(u_char *arg,
+                      const struct pcap_pkthdr *header,
+                      const u_char *packet)
+  {
+    ((PcapPacketsParser *)arg)->ParsePkt(header, packet);
+  }
+
+  const TcpdumpMysqlParserStats &GetStats() const { return stats; }
+
+  void WaitForUnfinishedTasks();
+
+  void CreateConnectionState(DBThread *db_thread);
+
+private:
+
+  void ParsePkt(const struct pcap_pkthdr *header,
+                const u_char *packet);
+
+};
+
+#endif //PERCONA_PLAYBACK_PCAP_PACKETS_PARSER_H
 
=== modified file 'percona_playback/tcpdump/plugin.ac'
--- percona_playback/tcpdump/plugin.ac	2012-06-19 01:09:31 +0000
+++ percona_playback/tcpdump/plugin.ac	2012-07-02 18:23:18 +0000
@@ -1,2 +1,2 @@
 PANDORA_HAVE_LIBPCAP
-PANDORA_HAVE_LIBDRIZZLE
+PANDORA_HAVE_LIBDRIZZLE_1_0
 
=== modified file 'percona_playback/tcpdump/plugin.ini'
--- percona_playback/tcpdump/plugin.ini	2012-06-19 01:09:31 +0000
+++ percona_playback/tcpdump/plugin.ini	2012-07-02 18:23:18 +0000
@@ -6,4 +6,6 @@
 headers=tcpdump.h
 load_by_default=yes
 ldflags=${PCAP_LIBS} ${LTLIBDRIZZLE} ${LDFLAGS}
-cppflags=${PCAP_INCLUDES} ${CPPFLAGS} 
+cppflags=${PCAP_INCLUDES} ${CPPFLAGS}
+headers=tcpdump.h sniff_headers.h connection_state.h pcap_packets_parser.h tcpdump_query_entries.h tcpdump_mysql_parser_stats.h
+sources=tcpdump.cc connection_state.cc pcap_packets_parser.cc tcpdump_query_entries.cc
 
=== added file 'percona_playback/tcpdump/sniff_headers.h'
--- percona_playback/tcpdump/sniff_headers.h	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/sniff_headers.h	2012-07-02 18:23:18 +0000
@@ -0,0 +1,59 @@
+/* ethernet headers are always exactly 14 bytes [1] */
+#define SIZE_ETHERNET 14
+
+/* Ethernet addresses are 6 bytes */
+#define ETHER_ADDR_LEN	6
+
+//#pragma pack(push, 1)
+/* Ethernet header */
+struct sniff_ethernet {
+        u_char  ether_dhost[ETHER_ADDR_LEN];    /* destination host address */
+        u_char  ether_shost[ETHER_ADDR_LEN];    /* source host address */
+        u_short ether_type;                     /* IP? ARP? RARP? etc */
+};
+
+/* IP header */
+struct sniff_ip {
+        u_char  ip_vhl;                 /* version << 4 | header length >> 2 */
+        u_char  ip_tos;                 /* type of service */
+        u_short ip_len;                 /* total length */
+        u_short ip_id;                  /* identification */
+        u_short ip_off;                 /* fragment offset field */
+        #define IP_RF 0x8000            /* reserved fragment flag */
+        #define IP_DF 0x4000            /* dont fragment flag */
+        #define IP_MF 0x2000            /* more fragments flag */
+        #define IP_OFFMASK 0x1fff       /* mask for fragmenting bits */
+        u_char  ip_ttl;                 /* time to live */
+        u_char  ip_p;                   /* protocol */
+        u_short ip_sum;                 /* checksum */
+        struct  in_addr ip_src,ip_dst;  /* source and dest address */
+};
+#define IP_HL(ip)               (((ip)->ip_vhl) & 0x0f)
+#define IP_V(ip)                (((ip)->ip_vhl) >> 4)
+
+/* TCP header */
+typedef u_int tcp_seq;
+
+struct sniff_tcp {
+        u_short th_sport;               /* source port */
+        u_short th_dport;               /* destination port */
+        tcp_seq th_seq;                 /* sequence number */
+        tcp_seq th_ack;                 /* acknowledgement number */
+        u_char  th_offx2;               /* data offset, rsvd */
+#define TH_OFF(th)      (((th)->th_offx2 & 0xf0) >> 4)
+        u_char  th_flags;
+        #define TH_FIN  0x01
+        #define TH_SYN  0x02
+        #define TH_RST  0x04
+        #define TH_PUSH 0x08
+        #define TH_ACK  0x10
+        #define TH_URG  0x20
+        #define TH_ECE  0x40
+        #define TH_CWR  0x80
+        #define TH_FLAGS        (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
+        u_short th_win;                 /* window */
+        u_short th_sum;                 /* checksum */
+        u_short th_urp;                 /* urgent pointer */
+};
+
+//#pragma pack(pop)
 
=== modified file 'percona_playback/tcpdump/tcpdump.cc'
--- percona_playback/tcpdump/tcpdump.cc	2012-06-19 01:09:31 +0000
+++ percona_playback/tcpdump/tcpdump.cc	2012-07-02 18:23:18 +0000
@@ -14,15 +14,54 @@
  * END LICENSE */
 
 #include "tcpdump.h"
+#include "pcap_packets_parser.h"
+
+#include "percona_playback/percona_playback.h"
+
 #include <stdio.h>
+#include <pcap.h>
+
+#define FILTER_EXP_SIZE     11     // max filter expression size
+
+std::string         g_tcpdump_file_name;
+uint16_t            g_tcpdump_port;
+TcpdumpPluginMode   g_tcpdump_mode;
+
+std::istream& operator>>(std::istream& in, TcpdumpPluginMode& unit)
+{
+    std::string token;
+    in >> token;
+    if (token == "fast")
+        unit = TCPDUMP_MODE_FAST;
+    else if (token == "accurate")
+        unit = TCPDUMP_MODE_ACCURATE;
+    else
+      throw
+        boost::program_options::validation_error(
+          "Allowed input-type values are (fast|accurate)"
+        );
+    return in;
+}
 
 boost::program_options::options_description*
 TcpDumpParserPlugin::getProgramOptions()
 {
   options.add_options()
     ("tcpdump-file",
-     boost::program_options::value<std::string>(&file_name),
-     "Tcpdump file name");
+     boost::program_options::value<std::string>(&g_tcpdump_file_name),
+     "Tcpdump file name")
+    ("tcpdump-port",
+     boost::program_options::value<uint16_t>(&g_tcpdump_port)
+       ->default_value(3306),
+     "Tcpdump port")
+    ("tcpdump-mode",
+     boost::program_options::value<TcpdumpPluginMode>(&g_tcpdump_mode)
+       ->multitoken()->default_value(TCPDUMP_MODE_FAST, "fast"),
+     "The mode of tcpdump plugin (fast|accurate), in 'fast' mode "
+     "the plugin executes queries as fast as it can whereas in "
+     "'accurate' mode the plugin preserves queries execution time "
+    "and pauses between queries")
+    ;
 
   return &options;
 }
@@ -32,7 +71,9 @@
   boost::program_options::variables_map &vm)
 {
   if (!active &&
-      (vm.count("tcpdump-file")))
+      (vm.count("tcpdump-file") ||
+       !vm["tcpdump-port"].defaulted() ||
+       !vm["tcpdump-mode"].defaulted()))
   {
       fprintf(stderr, 
               gettext("tcpdump plugin is not selected, "
@@ -40,9 +81,87 @@
                       "command line options\n"));
       return -1;
   }
+
+  if (!active)
+    return 0;
+
+  if (!vm.count("tcpdump-file"))
+  {
+    fprintf(stderr,
+            gettext("tcpdump-file argument is requred\n"));
+    return -1;
+  }
+
   return 0;
 }
 
+void
+TcpDumpParserPlugin::run(percona_playback_run_result  &r)
+{
+  char                errbuf[PCAP_ERRBUF_SIZE];
+  pcap_t              *handle;
+  struct              bpf_program fp;
+  char                filter_exp[11];
+  PcapPacketsParser   packets_parser;
+
+
+  if (g_tcpdump_file_name.empty())
+  {
+    r.err= -1;
+    return;
+  }
+
+  handle = pcap_open_offline(g_tcpdump_file_name.c_str(), errbuf);
+
+  if (handle == NULL)
+  {
+    std::cerr << "Couldn't open file " <<  g_tcpdump_file_name << ": " 
+              << errbuf << std::endl;
+    r.err= -1;
+    return;
+  }
+
+  snprintf(filter_exp, FILTER_EXP_SIZE, "port %u", (unsigned)g_tcpdump_port);
+
+  if(pcap_compile(handle, &fp, filter_exp, 0, 0) == -1)
+  {
+    std::cerr << "Couldn't parse filter " << filter_exp << ": "
+              << pcap_geterr(handle) << std::endl;
+    r.err= -1;
+    return;
+  }
+
+  if (pcap_setfilter(handle, &fp) == -1)
+  {
+    std::cerr << "Couldn't install filter " << filter_exp << ": "
+              << pcap_geterr(handle) << std::endl;
+    r.err= -1;
+    return;
+  }
+
+  if (pcap_loop(handle,
+                -1,
+                PcapPacketsParser::Process,
+                (u_char *)&packets_parser) < 0)
+  {
+    std::cerr << "pcap_loop error "
+              << pcap_geterr(handle) << std::endl;
+    r.err= -1;
+    return;
+  }
+
+  /* Wait for unfinished DBThreads */
+  packets_parser.WaitForUnfinishedTasks();
+
+  const TcpdumpMysqlParserStats &stats= packets_parser.GetStats();
+ 
+  r.n_log_entries=   stats.nr_of_parsed_packets;
+  r.n_queries=       stats.nr_of_parsed_queries;
+  r.err=             stats.nr_of_parsing_errors;
+  
+  return;
+}
+
 static void init_plugin(percona_playback::PluginRegistry &r)
 {
   r.add("tcpdump", new TcpDumpParserPlugin("tcpdump"));
 
=== modified file 'percona_playback/tcpdump/tcpdump.h'
--- percona_playback/tcpdump/tcpdump.h	2012-06-24 04:28:41 +0000
+++ percona_playback/tcpdump/tcpdump.h	2012-07-02 18:23:18 +0000
@@ -19,9 +19,17 @@
 #include <percona_playback/plugin.h>
 
 #include <boost/program_options.hpp>
+#include <string>
+
+enum TcpdumpPluginMode
+{
+  TCPDUMP_MODE_FAST,
+  TCPDUMP_MODE_ACCURATE
+};
 
 class TcpDumpParserPlugin : public percona_playback::InputPlugin
 {
+  boost::program_options::options_description options;
 
 public:
   TcpDumpParserPlugin(const std::string &_name) :
@@ -33,11 +41,20 @@
 
   virtual int processOptions(boost::program_options::variables_map &vm);
 
+<<<<<<< TREE
   virtual void run(percona_playback_run_result  &) {}
 
 
   std::string file_name;
   boost::program_options::options_description options;
+=======
+  virtual void run(percona_playback_run_result  &result);
+>>>>>>> MERGE-SOURCE
 };
 
+extern std::string         g_tcpdump_file_name;
+extern uint16_t            g_tcpdump_port;
+extern TcpdumpPluginMode   g_tcpdump_mode;
+
+
 #endif /* PERCONA_PLAYBACK_TCPDUMP_PARSER_H */
 
=== added file 'percona_playback/tcpdump/tcpdump_mysql_parser_stats.h'
--- percona_playback/tcpdump/tcpdump_mysql_parser_stats.h	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/tcpdump_mysql_parser_stats.h	2012-07-02 18:23:18 +0000
@@ -0,0 +1,33 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#ifndef PERCONA_PLAYBACK_TCPDUMP_MYSQL_PARSER_STATS_H
+#define PERCONA_PLAYBACK_TCPDUMP_MYSQL_PARSER_STATS_H
+
+struct TcpdumpMysqlParserStats
+{
+  size_t            nr_of_parsed_packets;
+  size_t            nr_of_parsed_queries;
+  size_t            nr_of_parsing_errors;
+  
+  TcpdumpMysqlParserStats() :
+    nr_of_parsed_packets(0),
+    nr_of_parsed_queries(0),
+    nr_of_parsing_errors(0)
+  {}
+
+};
+
+#endif //PERCONA_PLAYBACK_TCPDUMP_MYSQL_PARSER_STATS_H
 
=== added file 'percona_playback/tcpdump/tcpdump_query_entries.cc'
--- percona_playback/tcpdump/tcpdump_query_entries.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/tcpdump_query_entries.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,129 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+#include "tcpdump_query_entries.h"
+#include "tcpdump.h"
+#include "percona_playback/db_thread.h"
+#include "percona_playback/plugin.h"
+
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/foreach.hpp>
+#include <boost/shared_ptr.hpp>
+#include <string.h>
+#include <iostream>
+#include <assert.h>
+
+void
+TcpdumpQueryEntry::execute(DBThread *t)
+{
+  QueryResult expected_result;
+  boost::posix_time::ptime start_time;
+  boost::posix_time::ptime end_time;
+  boost::shared_ptr<DBThreadState> thr_state;
+
+  assert(t);
+
+  thr_state= t->get_state();
+
+  assert(thr_state.get());
+
+  ConnectionState &state= (ConnectionState &)*thr_state;
+
+  LastExecutedQueryInfo &last_query_info= state.last_executed_query_info;
+
+  if (g_tcpdump_mode == TCPDUMP_MODE_ACCURATE &&
+      last_query_info.end_timestamp.tv_sec != 0 &&
+      last_query_info.end_timestamp.tv_usec != 0 &&
+      last_query_info.end_pcap_timestamp.tv_sec != 0 &&
+      last_query_info.end_pcap_timestamp.tv_usec != 0)
+  {
+    timeval current_timestamp;
+    timeval pause_time;
+    timeval pcap_pause_time;
+
+    gettimeofday(&current_timestamp, NULL);
+    timersub(&current_timestamp, &last_query_info.end_timestamp, &pause_time);
+
+    timersub(&pcap_timestamp,
+             &last_query_info.end_pcap_timestamp,
+             &pcap_pause_time);
+
+    if (timercmp(&pause_time, &pcap_pause_time, <))
+    {
+      timeval time_to_sleep;
+      timersub(&pcap_pause_time,
+               &pause_time,
+               &time_to_sleep);
+      usleep(time_to_sleep.tv_sec*1000000 + time_to_sleep.tv_usec);
+    }
+  }
+
+  last_query_info.result.clear();
+
+  start_time= boost::posix_time::microsec_clock::universal_time();
+  t->execute_query(query, &last_query_info.result, expected_result);
+  end_time= boost::posix_time::microsec_clock::universal_time();
+
+  boost::posix_time::time_period duration(start_time, end_time);
+  last_query_info.result.setDuration(duration.length());
+  last_query_info.begin_pcap_timestamp= pcap_timestamp;
+  last_query_info.query= query;
+}
+
+void
+TcpdumpResultEntry::execute(DBThread *t)
+{
+  timeval query_execution_time;
+  boost::shared_ptr<DBThreadState> thr_state;
+  
+  assert(t);
+  
+  thr_state= t->get_state();
+
+  assert(thr_state.get());
+
+
+  ConnectionState &state= (ConnectionState &)*thr_state;
+  LastExecutedQueryInfo &last_query_info= state.last_executed_query_info;
+
+  timersub(&pcap_timestamp,
+           &last_query_info.begin_pcap_timestamp,
+           &query_execution_time);
+
+  expected_result.setDuration(
+    boost::posix_time::microseconds(
+      query_execution_time.tv_usec +
+      query_execution_time.tv_sec*1000000));
+
+  if (g_tcpdump_mode == TCPDUMP_MODE_ACCURATE &&
+      (expected_result.getDuration() > last_query_info.result.getDuration()))
+  {
+    boost::posix_time::time_duration us_sleep_time=
+      expected_result.getDuration() - last_query_info.result.getDuration();
+
+    usleep(us_sleep_time.total_microseconds());
+  }
+
+  gettimeofday(&last_query_info.end_timestamp, NULL);
+  last_query_info.end_pcap_timestamp= pcap_timestamp;
+
+  BOOST_FOREACH(const percona_playback::PluginRegistry::ReportPluginPair pp,
+                percona_playback::PluginRegistry::singleton().report_plugins)
+  {
+    pp.second->query_execution(getThreadId(),
+                               last_query_info.query,
+                               expected_result,
+                               last_query_info.result);
+  }
+}
 
=== added file 'percona_playback/tcpdump/tcpdump_query_entries.h'
--- percona_playback/tcpdump/tcpdump_query_entries.h	1970-01-01 00:00:00 +0000
+++ percona_playback/tcpdump/tcpdump_query_entries.h	2012-07-02 18:23:18 +0000
@@ -0,0 +1,73 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#ifndef PERCONA_PLAYBACK_TCPDUMP_QUERY_ENTRIES_H
+#define PERCONA_PLAYBACK_TCPDUMP_QUERY_ENTRIES_H
+
+#include "percona_playback/query_entry.h"
+#include "percona_playback/query_result.h"
+#include "connection_state.h"
+
+#include <sys/time.h>
+
+class TcpdumpQueryEntry : public QueryEntry
+{
+  timeval       pcap_timestamp;
+  std::string   query;
+
+public:
+
+  TcpdumpQueryEntry()
+  {
+    pcap_timestamp.tv_sec= pcap_timestamp.tv_usec= 0;
+  }
+
+  TcpdumpQueryEntry(const timeval       &pcap_timestamp,
+                    const std::string   &query,
+                    const AddrPort      &addr_port) :
+    QueryEntry(addr_port.ThreadId(), false),
+    pcap_timestamp(pcap_timestamp),
+    query(query)
+  {}
+
+  bool is_quit() { return false; }
+
+  void execute(DBThread *t);
+};
+
+class TcpdumpResultEntry : public QueryEntry
+{
+
+  timeval       pcap_timestamp;
+  QueryResult   expected_result;
+
+public:
+  TcpdumpResultEntry() {}
+  TcpdumpResultEntry(const AddrPort     &addr_port,
+                     const timeval      &pcap_timestamp,
+                     const QueryResult  &expected_result) :
+    QueryEntry(addr_port.ThreadId(), false),
+    pcap_timestamp(pcap_timestamp),
+    expected_result(expected_result)
+  {}
+
+  bool is_quit() { return false; }
+
+  void execute(DBThread *t);
+
+};
+
+#endif// PERCONA_PLAYBACK_TCPDUMP_QUERY_ENTRIES_H
+
 
=== added file 'percona_playback/test/tcpdump_accuracy.cc'
--- percona_playback/test/tcpdump_accuracy.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/test/tcpdump_accuracy.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,69 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU General Public License version 3, as published 
+ * by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#include "config.h"
+#include <iostream>
+#include <assert.h>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "percona_playback/percona_playback.h"
+#include "percona_playback/plugin.h"
+
+const size_t pp_argc= 5;
+
+int main(int, char **argv)
+{
+  percona_playback_st *the_percona_playback= percona_playback_create("test_Percona Playback");
+  assert(the_percona_playback);
+
+  char *pp_argv[pp_argc];
+  char pp_argv_0[]= "--db-plugin=null";
+  char pp_argv_1[]= "--input-plugin=tcpdump";
+  char pp_argv_2[]= "--tcpdump-file="
+                      SRCDIR
+                      "/percona_playback/test"
+                      "/tcpdump_accuracy.dump";
+  char pp_argv_3[]= "--tcpdump-mode=accurate";
+
+  pp_argv[0]= argv[0];
+  pp_argv[1]= pp_argv_0;
+  pp_argv[2]= pp_argv_1;
+  pp_argv[3]= pp_argv_2;
+  pp_argv[4]= pp_argv_3;
+
+  assert(0 == percona_playback_argv(the_percona_playback,
+                                    pp_argc,
+                                    pp_argv));
+
+  boost::posix_time::ptime start_time;
+  start_time= boost::posix_time::microsec_clock::universal_time();
+
+  struct percona_playback_run_result *r=
+    percona_playback_run(the_percona_playback);
+
+  boost::posix_time::ptime end_time;
+  end_time= boost::posix_time::microsec_clock::universal_time();
+
+  boost::posix_time::time_period duration(start_time, end_time);
+
+  assert(duration.length().total_microseconds() > 4000000);
+
+  assert(r->err == 0);
+  assert(r->n_queries == 60);
+  assert(r->n_log_entries == 480);
+
+  percona_playback_destroy(&the_percona_playback);
+  return r->err;
+}
 
=== added file 'percona_playback/test/tcpdump_accuracy.dump'
 Binary files percona_playback/test/tcpdump_accuracy.dump	1970-01-01 00:00:00 +0000 and percona_playback/test/tcpdump_accuracy.dump	2012-07-02 18:23:18 +0000 differ
=== added file 'percona_playback/test/tcpdump_fragmented_packet.cc'
--- percona_playback/test/tcpdump_fragmented_packet.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/test/tcpdump_fragmented_packet.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,56 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU General Public License version 3, as published 
+ * by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#include "config.h"
+#include <iostream>
+#include <assert.h>
+#include "percona_playback/percona_playback.h"
+#include "percona_playback/plugin.h"
+
+const size_t pp_argc= 4;
+
+int main(int, char **argv)
+{
+  percona_playback_st *the_percona_playback= percona_playback_create("test_Percona Playback");
+  assert(the_percona_playback);
+
+  char *pp_argv[pp_argc];
+  char pp_argv_0[]= "--db-plugin=null";
+  char pp_argv_1[]= "--input-plugin=tcpdump";
+  char pp_argv_2[]= "--tcpdump-file="
+                      SRCDIR
+                      "/percona_playback/test"
+                      "/tcpdump_fragmented_packet.dump";
+
+
+  pp_argv[0]= argv[0];
+  pp_argv[1]= pp_argv_0;
+  pp_argv[2]= pp_argv_1;
+  pp_argv[3]= pp_argv_2;
+
+  assert(0 == percona_playback_argv(the_percona_playback,
+                                    pp_argc,
+                                    pp_argv));
+
+  struct percona_playback_run_result *r=
+    percona_playback_run(the_percona_playback);
+
+  assert(r->err == 0);
+  assert(r->n_queries == 1);
+  assert(r->n_log_entries == 6);
+
+  percona_playback_destroy(&the_percona_playback);
+  return r->err;
+}
 
=== added file 'percona_playback/test/tcpdump_fragmented_packet.dump'
 Binary files percona_playback/test/tcpdump_fragmented_packet.dump	1970-01-01 00:00:00 +0000 and percona_playback/test/tcpdump_fragmented_packet.dump	2012-07-02 18:23:18 +0000 differ
=== added file 'percona_playback/test/tcpdump_multiple_connections.cc'
--- percona_playback/test/tcpdump_multiple_connections.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/test/tcpdump_multiple_connections.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,56 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU General Public License version 3, as published 
+ * by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#include "config.h"
+#include <iostream>
+#include <assert.h>
+#include "percona_playback/percona_playback.h"
+#include "percona_playback/plugin.h"
+
+const size_t pp_argc= 4;
+
+int main(int, char **argv)
+{
+  percona_playback_st *the_percona_playback= percona_playback_create("test_Percona Playback");
+  assert(the_percona_playback);
+
+  char *pp_argv[pp_argc];
+  char pp_argv_0[]= "--db-plugin=null";
+  char pp_argv_1[]= "--input-plugin=tcpdump";
+  char pp_argv_2[]= "--tcpdump-file="
+                      SRCDIR
+                      "/percona_playback/test"
+                      "/tcpdump_multiple_connections.dump";
+
+
+  pp_argv[0]= argv[0];
+  pp_argv[1]= pp_argv_0;
+  pp_argv[2]= pp_argv_1;
+  pp_argv[3]= pp_argv_2;
+
+  assert(0 == percona_playback_argv(the_percona_playback,
+                                    pp_argc,
+                                    pp_argv));
+
+  struct percona_playback_run_result *r=
+    percona_playback_run(the_percona_playback);
+
+  assert(r->err == 0);
+  assert(r->n_queries == 2000);
+  assert(r->n_log_entries == 16000);
+
+  percona_playback_destroy(&the_percona_playback);
+  return r->err;
+}
 
=== added file 'percona_playback/test/tcpdump_multiple_connections.dump'
 Binary files percona_playback/test/tcpdump_multiple_connections.dump	1970-01-01 00:00:00 +0000 and percona_playback/test/tcpdump_multiple_connections.dump	2012-07-02 18:23:18 +0000 differ
=== added file 'percona_playback/test/tcpdump_stress_test.cc'
--- percona_playback/test/tcpdump_stress_test.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/test/tcpdump_stress_test.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,56 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU General Public License version 3, as published 
+ * by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#include "config.h"
+#include <iostream>
+#include <assert.h>
+#include "percona_playback/percona_playback.h"
+#include "percona_playback/plugin.h"
+
+const size_t pp_argc= 4;
+
+int main(int, char **argv)
+{
+  percona_playback_st *the_percona_playback= percona_playback_create("test_Percona Playback");
+  assert(the_percona_playback);
+
+  char *pp_argv[pp_argc];
+  char pp_argv_0[]= "--db-plugin=null";
+  char pp_argv_1[]= "--input-plugin=tcpdump";
+  char pp_argv_2[]= "--tcpdump-file="
+                      SRCDIR
+                      "/percona_playback/test"
+                      "/tcpdump_stress_test.dump";
+
+
+  pp_argv[0]= argv[0];
+  pp_argv[1]= pp_argv_0;
+  pp_argv[2]= pp_argv_1;
+  pp_argv[3]= pp_argv_2;
+
+  assert(0 == percona_playback_argv(the_percona_playback,
+                                    pp_argc,
+                                    pp_argv));
+
+  struct percona_playback_run_result *r=
+    percona_playback_run(the_percona_playback);
+
+  assert(r->err == 0);
+  assert(r->n_queries == 9088);
+  assert(r->n_log_entries == 62306);
+
+  percona_playback_destroy(&the_percona_playback);
+  return r->err;
+}
 
=== added file 'percona_playback/test/tcpdump_stress_test.dump'
 Binary files percona_playback/test/tcpdump_stress_test.dump	1970-01-01 00:00:00 +0000 and percona_playback/test/tcpdump_stress_test.dump	2012-07-02 18:23:18 +0000 differ
=== added file 'percona_playback/test/tcpdump_without_handshake.cc'
--- percona_playback/test/tcpdump_without_handshake.cc	1970-01-01 00:00:00 +0000
+++ percona_playback/test/tcpdump_without_handshake.cc	2012-07-02 18:23:18 +0000
@@ -0,0 +1,56 @@
+/* BEGIN LICENSE
+ * Copyright (C) 2011-2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it 
+ * under the terms of the GNU General Public License version 3, as published 
+ * by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranties of 
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+ * PURPOSE.  See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * END LICENSE */
+
+#include "config.h"
+#include <iostream>
+#include <assert.h>
+#include "percona_playback/percona_playback.h"
+#include "percona_playback/plugin.h"
+
+const size_t pp_argc= 4;
+
+int main(int, char **argv)
+{
+  percona_playback_st *the_percona_playback= percona_playback_create("test_Percona Playback");
+  assert(the_percona_playback);
+
+  char *pp_argv[pp_argc];
+  char pp_argv_0[]= "--db-plugin=null";
+  char pp_argv_1[]= "--input-plugin=tcpdump";
+  char pp_argv_2[]= "--tcpdump-file="
+                      SRCDIR
+                      "/percona_playback/test"
+                      "/tcpdump_without_handshake.dump";
+
+
+  pp_argv[0]= argv[0];
+  pp_argv[1]= pp_argv_0;
+  pp_argv[2]= pp_argv_1;
+  pp_argv[3]= pp_argv_2;
+
+  assert(0 == percona_playback_argv(the_percona_playback,
+                                    pp_argc,
+                                    pp_argv));
+
+  struct percona_playback_run_result *r=
+    percona_playback_run(the_percona_playback);
+
+  assert(r->err == 0);
+  assert(r->n_queries == 7);
+  assert(r->n_log_entries == 44);
+
+  percona_playback_destroy(&the_percona_playback);
+  return r->err;
+}
 
=== added file 'percona_playback/test/tcpdump_without_handshake.dump'
 Binary files percona_playback/test/tcpdump_without_handshake.dump	1970-01-01 00:00:00 +0000 and percona_playback/test/tcpdump_without_handshake.dump	2012-07-02 18:23:18 +0000 differ