ULTRA [ vsambulanceservice.com ]

Linux vps122157.inmotionhosting.com 4.18.0 #1 SMP Mon Sep 30 15:36:27 MSK 2024 x86_64

Apache/2.4.62 (Unix) OpenSSL/1.1.1k

199.250.210.201 | Your IP: 216.73.216.37

Cant read [ /etc/named.conf ]

[ dr-xr-xr-x ]

/ bin /

Home Upload Mass Deface Mass Delete Back Connect Notify

pt-index-usage

#!/usr/bin/env perl

# This program is part of Percona Toolkit: http://www.percona.com/software/
# See "COPYRIGHT, LICENSE, AND WARRANTY" at the end of this file for legal
# notices and disclaimers.

use strict;
use warnings FATAL => 'all';

# This tool is "fat-packed": most of its dependent modules are embedded
# in this file.  Setting %INC to this file for each module makes Perl aware
# of this so it will not try to load the module from @INC.  See the tool's
# documentation for a full list of dependencies.
BEGIN {
   $INC{$_} = __FILE__ for map { (my $pkg = "$_.pm") =~ s!::!/!g; $pkg } (qw(
      Percona::Toolkit
      DSNParser
      Quoter
      OptionParser
      PodParser
      QueryParser
      QueryRewriter
      SlowLogParser
      TableParser
      Transformers
      Schema
      SchemaIterator
      FileIterator
      ExplainAnalyzer
      IndexUsage
      Progress
      HTTP::Micro
      VersionCheck
   ));
}

# ###########################################################################
# Percona::Toolkit package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/Percona/Toolkit.pm
#   t/lib/Percona/Toolkit.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package Percona::Toolkit;

our $VERSION = '2.2.15';

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Carp qw(carp cluck);
use Data::Dumper qw();

require Exporter;
our @ISA         = qw(Exporter);
our @EXPORT_OK   = qw(
   have_required_args
   Dumper
   _d
);

sub have_required_args {
   my ($args, @required_args) = @_;
   my $have_required_args = 1;
   foreach my $arg ( @required_args ) {
      if ( !defined $args->{$arg} ) {
         $have_required_args = 0;
         carp "Argument $arg is not defined";
      }
   }
   cluck unless $have_required_args;  # print backtrace
   return $have_required_args;
}

sub Dumper {
   local $Data::Dumper::Indent    = 1;
   local $Data::Dumper::Sortkeys  = 1;
   local $Data::Dumper::Quotekeys = 0;
   Data::Dumper::Dumper(@_);
}

sub _d {
   my ($package, undef, $line) = caller 0;
   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
        map { defined $_ ? $_ : 'undef' }
        @_;
   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
}

1;
}
# ###########################################################################
# End Percona::Toolkit package
# ###########################################################################

# ###########################################################################
# DSNParser package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/DSNParser.pm
#   t/lib/DSNParser.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package DSNParser;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
$Data::Dumper::Indent    = 0;
$Data::Dumper::Quotekeys = 0;

my $dsn_sep = qr/(?<!\\),/;

eval {
   require DBI;
};
my $have_dbi = $EVAL_ERROR ? 0 : 1;

sub new {
   my ( $class, %args ) = @_;
   foreach my $arg ( qw(opts) ) {
      die "I need a $arg argument" unless $args{$arg};
   }
   my $self = {
      opts => {}  # h, P, u, etc.  Should come from DSN OPTIONS section in POD.
   };
   foreach my $opt ( @{$args{opts}} ) {
      if ( !$opt->{key} || !$opt->{desc} ) {
         die "Invalid DSN option: ", Dumper($opt);
      }
      PTDEBUG && _d('DSN option:',
         join(', ',
            map { "$_=" . (defined $opt->{$_} ? ($opt->{$_} || '') : 'undef') }
               keys %$opt
         )
      );
      $self->{opts}->{$opt->{key}} = {
         dsn  => $opt->{dsn},
         desc => $opt->{desc},
         copy => $opt->{copy} || 0,
      };
   }
   return bless $self, $class;
}

sub prop {
   my ( $self, $prop, $value ) = @_;
   if ( @_ > 2 ) {
      PTDEBUG && _d('Setting', $prop, 'property');
      $self->{$prop} = $value;
   }
   return $self->{$prop};
}

sub parse {
   my ( $self, $dsn, $prev, $defaults ) = @_;
   if ( !$dsn ) {
      PTDEBUG && _d('No DSN to parse');
      return;
   }
   PTDEBUG && _d('Parsing', $dsn);
   $prev     ||= {};
   $defaults ||= {};
   my %given_props;
   my %final_props;
   my $opts = $self->{opts};

foreach my $dsn_part ( split($dsn_sep, $dsn) ) {
      $dsn_part =~ s/\\,/,/g;
      if ( my ($prop_key, $prop_val) = $dsn_part =~  m/^(.)=(.*)$/ ) {
         $given_props{$prop_key} = $prop_val;
      }
      else {
         PTDEBUG && _d('Interpreting', $dsn_part, 'as h=', $dsn_part);
         $given_props{h} = $dsn_part;
      }
   }

foreach my $key ( keys %$opts ) {
      PTDEBUG && _d('Finding value for', $key);
      $final_props{$key} = $given_props{$key};
      if (   !defined $final_props{$key}
           && defined $prev->{$key} && $opts->{$key}->{copy} )
      {
         $final_props{$key} = $prev->{$key};
         PTDEBUG && _d('Copying value for', $key, 'from previous DSN');
      }
      if ( !defined $final_props{$key} ) {
         $final_props{$key} = $defaults->{$key};
         PTDEBUG && _d('Copying value for', $key, 'from defaults');
      }
   }

foreach my $key ( keys %given_props ) {
      die "Unknown DSN option '$key' in '$dsn'.  For more details, "
            . "please use the --help option, or try 'perldoc $PROGRAM_NAME' "
            . "for complete documentation."
         unless exists $opts->{$key};
   }
   if ( (my $required = $self->prop('required')) ) {
      foreach my $key ( keys %$required ) {
         die "Missing required DSN option '$key' in '$dsn'.  For more details, "
               . "please use the --help option, or try 'perldoc $PROGRAM_NAME' "
               . "for complete documentation."
            unless $final_props{$key};
      }
   }

return \%final_props;
}

sub parse_options {
   my ( $self, $o ) = @_;
   die 'I need an OptionParser object' unless ref $o eq 'OptionParser';
   my $dsn_string
      = join(',',
          map  { "$_=".$o->get($_); }
          grep { $o->has($_) && $o->get($_) }
          keys %{$self->{opts}}
        );
   PTDEBUG && _d('DSN string made from options:', $dsn_string);
   return $self->parse($dsn_string);
}

sub as_string {
   my ( $self, $dsn, $props ) = @_;
   return $dsn unless ref $dsn;
   my @keys = $props ? @$props : sort keys %$dsn;
   return join(',',
      map  { "$_=" . ($_ eq 'p' ? '...' : $dsn->{$_}) }
      grep {
         exists $self->{opts}->{$_}
         && exists $dsn->{$_}
         && defined $dsn->{$_}
      } @keys);
}

sub usage {
   my ( $self ) = @_;
   my $usage
      = "DSN syntax is key=value[,key=value...]  Allowable DSN keys:\n\n"
      . "  KEY  COPY  MEANING\n"
      . "  ===  ====  =============================================\n";
   my %opts = %{$self->{opts}};
   foreach my $key ( sort keys %opts ) {
      $usage .= "  $key    "
             .  ($opts{$key}->{copy} ? 'yes   ' : 'no    ')
             .  ($opts{$key}->{desc} || '[No description]')
             . "\n";
   }
   $usage .= "\n  If the DSN is a bareword, the word is treated as the 'h' key.\n";
   return $usage;
}

sub get_cxn_params {
   my ( $self, $info ) = @_;
   my $dsn;
   my %opts = %{$self->{opts}};
   my $driver = $self->prop('dbidriver') || '';
   if ( $driver eq 'Pg' ) {
      $dsn = 'DBI:Pg:dbname=' . ( $info->{D} || '' ) . ';'
         . join(';', map  { "$opts{$_}->{dsn}=$info->{$_}" }
                     grep { defined $info->{$_} }
                     qw(h P));
   }
   else {
      $dsn = 'DBI:mysql:' . ( $info->{D} || '' ) . ';'
         . join(';', map  { "$opts{$_}->{dsn}=$info->{$_}" }
                     grep { defined $info->{$_} }
                     qw(F h P S A))
         . ';mysql_read_default_group=client'
         . ($info->{L} ? ';mysql_local_infile=1' : '');
   }
   PTDEBUG && _d($dsn);
   return ($dsn, $info->{u}, $info->{p});
}

sub fill_in_dsn {
   my ( $self, $dbh, $dsn ) = @_;
   my $vars = $dbh->selectall_hashref('SHOW VARIABLES', 'Variable_name');
   my ($user, $db) = $dbh->selectrow_array('SELECT USER(), DATABASE()');
   $user =~ s/@.*//;
   $dsn->{h} ||= $vars->{hostname}->{Value};
   $dsn->{S} ||= $vars->{'socket'}->{Value};
   $dsn->{P} ||= $vars->{port}->{Value};
   $dsn->{u} ||= $user;
   $dsn->{D} ||= $db;
}

sub get_dbh {
   my ( $self, $cxn_string, $user, $pass, $opts ) = @_;
   $opts ||= {};
   my $defaults = {
      AutoCommit         => 0,
      RaiseError         => 1,
      PrintError         => 0,
      ShowErrorStatement => 1,
      mysql_enable_utf8 => ($cxn_string =~ m/charset=utf8/i ? 1 : 0),
   };
   @{$defaults}{ keys %$opts } = values %$opts;
   if (delete $defaults->{L}) { # L for LOAD DATA LOCAL INFILE, our own extension
      $defaults->{mysql_local_infile} = 1;
   }

if ( $opts->{mysql_use_result} ) {
      $defaults->{mysql_use_result} = 1;
   }

if ( !$have_dbi ) {
      die "Cannot connect to MySQL because the Perl DBI module is not "
         . "installed or not found.  Run 'perl -MDBI' to see the directories "
         . "that Perl searches for DBI.  If DBI is not installed, try:\n"
         . "  Debian/Ubuntu  apt-get install libdbi-perl\n"
         . "  RHEL/CentOS    yum install perl-DBI\n"
         . "  OpenSolaris    pkg install pkg:/SUNWpmdbi\n";

}

my $dbh;
   my $tries = 2;
   while ( !$dbh && $tries-- ) {
      PTDEBUG && _d($cxn_string, ' ', $user, ' ', $pass, 
         join(', ', map { "$_=>$defaults->{$_}" } keys %$defaults ));

$dbh = eval { DBI->connect($cxn_string, $user, $pass, $defaults) };

if ( !$dbh && $EVAL_ERROR ) {
         if ( $EVAL_ERROR =~ m/locate DBD\/mysql/i ) {
            die "Cannot connect to MySQL because the Perl DBD::mysql module is "
               . "not installed or not found.  Run 'perl -MDBD::mysql' to see "
               . "the directories that Perl searches for DBD::mysql.  If "
               . "DBD::mysql is not installed, try:\n"
               . "  Debian/Ubuntu  apt-get install libdbd-mysql-perl\n"
               . "  RHEL/CentOS    yum install perl-DBD-MySQL\n"
               . "  OpenSolaris    pgk install pkg:/SUNWapu13dbd-mysql\n";
         }
         elsif ( $EVAL_ERROR =~ m/not a compiled character set|character set utf8/ ) {
            PTDEBUG && _d('Going to try again without utf8 support');
            delete $defaults->{mysql_enable_utf8};
         }
         if ( !$tries ) {
            die $EVAL_ERROR;
         }
      }
   }

if ( $cxn_string =~ m/mysql/i ) {
      my $sql;

$sql = 'SELECT @@SQL_MODE';
      PTDEBUG && _d($dbh, $sql);
      my ($sql_mode) = eval { $dbh->selectrow_array($sql) };
      if ( $EVAL_ERROR ) {
         die "Error getting the current SQL_MODE: $EVAL_ERROR";
      }

if ( my ($charset) = $cxn_string =~ m/charset=([\w]+)/ ) {
         $sql = qq{/*!40101 SET NAMES "$charset"*/};
         PTDEBUG && _d($dbh, $sql);
         eval { $dbh->do($sql) };
         if ( $EVAL_ERROR ) {
            die "Error setting NAMES to $charset: $EVAL_ERROR";
         }
         PTDEBUG && _d('Enabling charset for STDOUT');
         if ( $charset eq 'utf8' ) {
            binmode(STDOUT, ':utf8')
               or die "Can't binmode(STDOUT, ':utf8'): $OS_ERROR";
         }
         else {
            binmode(STDOUT) or die "Can't binmode(STDOUT): $OS_ERROR";
         }
      }

if ( my $vars = $self->prop('set-vars') ) {
         $self->set_vars($dbh, $vars);
      }

$sql = 'SET @@SQL_QUOTE_SHOW_CREATE = 1'
            . '/*!40101, @@SQL_MODE=\'NO_AUTO_VALUE_ON_ZERO'
            . ($sql_mode ? ",$sql_mode" : '')
            . '\'*/';
      PTDEBUG && _d($dbh, $sql);
      eval { $dbh->do($sql) };
      if ( $EVAL_ERROR ) {
         die "Error setting SQL_QUOTE_SHOW_CREATE, SQL_MODE"
           . ($sql_mode ? " and $sql_mode" : '')
           . ": $EVAL_ERROR";
      }
   }

PTDEBUG && _d('DBH info: ',
      $dbh,
      Dumper($dbh->selectrow_hashref(
         'SELECT DATABASE(), CONNECTION_ID(), VERSION()/*!50038 , @@hostname*/')),
      'Connection info:',      $dbh->{mysql_hostinfo},
      'Character set info:',   Dumper($dbh->selectall_arrayref(
                     "SHOW VARIABLES LIKE 'character_set%'", { Slice => {}})),
      '$DBD::mysql::VERSION:', $DBD::mysql::VERSION,
      '$DBI::VERSION:',        $DBI::VERSION,
   );

return $dbh;
}

sub get_hostname {
   my ( $self, $dbh ) = @_;
   if ( my ($host) = ($dbh->{mysql_hostinfo} || '') =~ m/^(\w+) via/ ) {
      return $host;
   }
   my ( $hostname, $one ) = $dbh->selectrow_array(
      'SELECT /*!50038 @@hostname, */ 1');
   return $hostname;
}

sub disconnect {
   my ( $self, $dbh ) = @_;
   PTDEBUG && $self->print_active_handles($dbh);
   $dbh->disconnect;
}

sub print_active_handles {
   my ( $self, $thing, $level ) = @_;
   $level ||= 0;
   printf("# Active %sh: %s %s %s\n", ($thing->{Type} || 'undef'), "\t" x $level,
      $thing, (($thing->{Type} || '') eq 'st' ? $thing->{Statement} || '' : ''))
      or die "Cannot print: $OS_ERROR";
   foreach my $handle ( grep {defined} @{ $thing->{ChildHandles} } ) {
      $self->print_active_handles( $handle, $level + 1 );
   }
}

sub copy {
   my ( $self, $dsn_1, $dsn_2, %args ) = @_;
   die 'I need a dsn_1 argument' unless $dsn_1;
   die 'I need a dsn_2 argument' unless $dsn_2;
   my %new_dsn = map {
      my $key = $_;
      my $val;
      if ( $args{overwrite} ) {
         $val = defined $dsn_1->{$key} ? $dsn_1->{$key} : $dsn_2->{$key};
      }
      else {
         $val = defined $dsn_2->{$key} ? $dsn_2->{$key} : $dsn_1->{$key};
      }
      $key => $val;
   } keys %{$self->{opts}};
   return \%new_dsn;
}

sub set_vars {
   my ($self, $dbh, $vars) = @_;

return unless $vars;

foreach my $var ( sort keys %$vars ) {
      my $val = $vars->{$var}->{val};

(my $quoted_var = $var) =~ s/_/\\_/;
      my ($var_exists, $current_val);
      eval {
         ($var_exists, $current_val) = $dbh->selectrow_array(
            "SHOW VARIABLES LIKE '$quoted_var'");
      };
      my $e = $EVAL_ERROR;
      if ( $e ) {
         PTDEBUG && _d($e);
      }

if ( $vars->{$var}->{default} && !$var_exists ) {
         PTDEBUG && _d('Not setting default var', $var,
            'because it does not exist');
         next;
      }

if ( $current_val && $current_val eq $val ) {
         PTDEBUG && _d('Not setting var', $var, 'because its value',
            'is already', $val);
         next;
      }

my $sql = "SET SESSION $var=$val";
      PTDEBUG && _d($dbh, $sql);
      eval { $dbh->do($sql) };
      if ( my $set_error = $EVAL_ERROR ) {
         chomp($set_error);
         $set_error =~ s/ at \S+ line \d+//;
         my $msg = "Error setting $var: $set_error";
         if ( $current_val ) {
            $msg .= "  The current value for $var is $current_val.  "
                  . "If the variable is read only (not dynamic), specify "
                  . "--set-vars $var=$current_val to avoid this warning, "
                  . "else manually set the variable and restart MySQL.";
         }
         warn $msg . "\n\n";
      }
   }

return; 
}

1;
}
# ###########################################################################
# End DSNParser package
# ###########################################################################

# ###########################################################################
# Quoter package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/Quoter.pm
#   t/lib/Quoter.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package Quoter;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
$Data::Dumper::Indent    = 1;
$Data::Dumper::Sortkeys  = 1;
$Data::Dumper::Quotekeys = 0;

sub new {
   my ( $class, %args ) = @_;
   return bless {}, $class;
}

sub quote {
   my ( $self, @vals ) = @_;
   foreach my $val ( @vals ) {
      $val =~ s/`/``/g;
   }
   return join('.', map { '`' . $_ . '`' } @vals);
}

sub quote_val {
   my ( $self, $val, %args ) = @_;

return 'NULL' unless defined $val;          # undef = NULL
   return "''" if $val eq '';                  # blank string = ''
   return $val if $val =~ m/^0x[0-9a-fA-F]+$/  # quote hex data
                  && !$args{is_char};          # unless is_char is true

$val =~ s/(['\\])/\\$1/g;
   return "'$val'";
}

sub split_unquote {
   my ( $self, $db_tbl, $default_db ) = @_;
   my ( $db, $tbl ) = split(/[.]/, $db_tbl);
   if ( !$tbl ) {
      $tbl = $db;
      $db  = $default_db;
   }
   for ($db, $tbl) {
      next unless $_;
      s/\A`//;
      s/`\z//;
      s/``/`/g;
   }
   
   return ($db, $tbl);
}

sub literal_like {
   my ( $self, $like ) = @_;
   return unless $like;
   $like =~ s/([%_])/\\$1/g;
   return "'$like'";
}

sub join_quote {
   my ( $self, $default_db, $db_tbl ) = @_;
   return unless $db_tbl;
   my ($db, $tbl) = split(/[.]/, $db_tbl);
   if ( !$tbl ) {
      $tbl = $db;
      $db  = $default_db;
   }
   $db  = "`$db`"  if $db  && $db  !~ m/^`/;
   $tbl = "`$tbl`" if $tbl && $tbl !~ m/^`/;
   return $db ? "$db.$tbl" : $tbl;
}

sub serialize_list {
   my ( $self, @args ) = @_;
   PTDEBUG && _d('Serializing', Dumper(\@args));
   return unless @args;

my @parts;
   foreach my $arg  ( @args ) {
      if ( defined $arg ) {
         $arg =~ s/,/\\,/g;      # escape commas
         $arg =~ s/\\N/\\\\N/g;  # escape literal \N
         push @parts, $arg;
      }
      else {
         push @parts, '\N';
      }
   }

my $string = join(',', @parts);
   PTDEBUG && _d('Serialized: <', $string, '>');
   return $string;
}

sub deserialize_list {
   my ( $self, $string ) = @_;
   PTDEBUG && _d('Deserializing <', $string, '>');
   die "Cannot deserialize an undefined string" unless defined $string;

my @parts;
   foreach my $arg ( split(/(?<!\\),/, $string) ) {
      if ( $arg eq '\N' ) {
         $arg = undef;
      }
      else {
         $arg =~ s/\\,/,/g;
         $arg =~ s/\\\\N/\\N/g;
      }
      push @parts, $arg;
   }

if ( !@parts ) {
      my $n_empty_strings = $string =~ tr/,//;
      $n_empty_strings++;
      PTDEBUG && _d($n_empty_strings, 'empty strings');
      map { push @parts, '' } 1..$n_empty_strings;
   }
   elsif ( $string =~ m/(?<!\\),$/ ) {
      PTDEBUG && _d('Last value is an empty string');
      push @parts, '';
   }

PTDEBUG && _d('Deserialized', Dumper(\@parts));
   return @parts;
}

1;
}
# ###########################################################################
# End Quoter package
# ###########################################################################

# ###########################################################################
# OptionParser package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/OptionParser.pm
#   t/lib/OptionParser.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package OptionParser;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use List::Util qw(max);
use Getopt::Long;
use Data::Dumper;

my $POD_link_re = '[LC]<"?([^">]+)"?>';

sub new {
   my ( $class, %args ) = @_;
   my @required_args = qw();
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }

my ($program_name) = $PROGRAM_NAME =~ m/([.A-Za-z-]+)$/;
   $program_name ||= $PROGRAM_NAME;
   my $home = $ENV{HOME} || $ENV{HOMEPATH} || $ENV{USERPROFILE} || '.';

my %attributes = (
      'type'       => 1,
      'short form' => 1,
      'group'      => 1,
      'default'    => 1,
      'cumulative' => 1,
      'negatable'  => 1,
   );

my $self = {
      head1             => 'OPTIONS',        # These args are used internally
      skip_rules        => 0,                # to instantiate another Option-
      item              => '--(.*)',         # Parser obj that parses the
      attributes        => \%attributes,     # DSN OPTIONS section.  Tools
      parse_attributes  => \&_parse_attribs, # don't tinker with these args.

%args,

strict            => 1,  # disabled by a special rule
      program_name      => $program_name,
      opts              => {},
      got_opts          => 0,
      short_opts        => {},
      defaults          => {},
      groups            => {},
      allowed_groups    => {},
      errors            => [],
      rules             => [],  # desc of rules for --help
      mutex             => [],  # rule: opts are mutually exclusive
      atleast1          => [],  # rule: at least one opt is required
      disables          => {},  # rule: opt disables other opts 
      defaults_to       => {},  # rule: opt defaults to value of other opt
      DSNParser         => undef,
      default_files     => [
         "/etc/percona-toolkit/percona-toolkit.conf",
         "/etc/percona-toolkit/$program_name.conf",
         "$home/.percona-toolkit.conf",
         "$home/.$program_name.conf",
      ],
      types             => {
         string => 's', # standard Getopt type
         int    => 'i', # standard Getopt type
         float  => 'f', # standard Getopt type
         Hash   => 'H', # hash, formed from a comma-separated list
         hash   => 'h', # hash as above, but only if a value is given
         Array  => 'A', # array, similar to Hash
         array  => 'a', # array, similar to hash
         DSN    => 'd', # DSN
         size   => 'z', # size with kMG suffix (powers of 2^10)
         time   => 'm', # time, with an optional suffix of s/h/m/d
      },
   };

return bless $self, $class;
}

sub get_specs {
   my ( $self, $file ) = @_;
   $file ||= $self->{file} || __FILE__;
   my @specs = $self->_pod_to_specs($file);
   $self->_parse_specs(@specs);

open my $fh, "<", $file or die "Cannot open $file: $OS_ERROR";
   my $contents = do { local $/ = undef; <$fh> };
   close $fh;
   if ( $contents =~ m/^=head1 DSN OPTIONS/m ) {
      PTDEBUG && _d('Parsing DSN OPTIONS');
      my $dsn_attribs = {
         dsn  => 1,
         copy => 1,
      };
      my $parse_dsn_attribs = sub {
         my ( $self, $option, $attribs ) = @_;
         map {
            my $val = $attribs->{$_};
            if ( $val ) {
               $val    = $val eq 'yes' ? 1
                       : $val eq 'no'  ? 0
                       :                 $val;
               $attribs->{$_} = $val;
            }
         } keys %$attribs;
         return {
            key => $option,
            %$attribs,
         };
      };
      my $dsn_o = new OptionParser(
         description       => 'DSN OPTIONS',
         head1             => 'DSN OPTIONS',
         dsn               => 0,         # XXX don't infinitely recurse!
         item              => '\* (.)',  # key opts are a single character
         skip_rules        => 1,         # no rules before opts
         attributes        => $dsn_attribs,
         parse_attributes  => $parse_dsn_attribs,
      );
      my @dsn_opts = map {
         my $opts = {
            key  => $_->{spec}->{key},
            dsn  => $_->{spec}->{dsn},
            copy => $_->{spec}->{copy},
            desc => $_->{desc},
         };
         $opts;
      } $dsn_o->_pod_to_specs($file);
      $self->{DSNParser} = DSNParser->new(opts => \@dsn_opts);
   }

if ( $contents =~ m/^=head1 VERSION\n\n^(.+)$/m ) {
      $self->{version} = $1;
      PTDEBUG && _d($self->{version});
   }

return;
}

sub DSNParser {
   my ( $self ) = @_;
   return $self->{DSNParser};
};

sub get_defaults_files {
   my ( $self ) = @_;
   return @{$self->{default_files}};
}

sub _pod_to_specs {
   my ( $self, $file ) = @_;
   $file ||= $self->{file} || __FILE__;
   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";

my @specs = ();
   my @rules = ();
   my $para;

local $INPUT_RECORD_SEPARATOR = '';
   while ( $para = <$fh> ) {
      next unless $para =~ m/^=head1 $self->{head1}/;
      last;
   }

while ( $para = <$fh> ) {
      last if $para =~ m/^=over/;
      next if $self->{skip_rules};
      chomp $para;
      $para =~ s/\s+/ /g;
      $para =~ s/$POD_link_re/$1/go;
      PTDEBUG && _d('Option rule:', $para);
      push @rules, $para;
   }

die "POD has no $self->{head1} section" unless $para;

do {
      if ( my ($option) = $para =~ m/^=item $self->{item}/ ) {
         chomp $para;
         PTDEBUG && _d($para);
         my %attribs;

$para = <$fh>; # read next paragraph, possibly attributes

if ( $para =~ m/: / ) { # attributes
            $para =~ s/\s+\Z//g;
            %attribs = map {
                  my ( $attrib, $val) = split(/: /, $_);
                  die "Unrecognized attribute for --$option: $attrib"
                     unless $self->{attributes}->{$attrib};
                  ($attrib, $val);
               } split(/; /, $para);
            if ( $attribs{'short form'} ) {
               $attribs{'short form'} =~ s/-//;
            }
            $para = <$fh>; # read next paragraph, probably short help desc
         }
         else {
            PTDEBUG && _d('Option has no attributes');
         }

$para =~ s/\s+\Z//g;
         $para =~ s/\s+/ /g;
         $para =~ s/$POD_link_re/$1/go;

$para =~ s/\.(?:\n.*| [A-Z].*|\Z)//s;
         PTDEBUG && _d('Short help:', $para);

die "No description after option spec $option" if $para =~ m/^=item/;

if ( my ($base_option) =  $option =~ m/^\[no\](.*)/ ) {
            $option = $base_option;
            $attribs{'negatable'} = 1;
         }

push @specs, {
            spec  => $self->{parse_attributes}->($self, $option, \%attribs), 
            desc  => $para
               . (defined $attribs{default} ? " (default $attribs{default})" : ''),
            group => ($attribs{'group'} ? $attribs{'group'} : 'default'),
         };
      }
      while ( $para = <$fh> ) {
         last unless $para;
         if ( $para =~ m/^=head1/ ) {
            $para = undef; # Can't 'last' out of a do {} block.
            last;
         }
         last if $para =~ m/^=item /;
      }
   } while ( $para );

die "No valid specs in $self->{head1}" unless @specs;

close $fh;
   return @specs, @rules;
}

sub _parse_specs {
   my ( $self, @specs ) = @_;
   my %disables; # special rule that requires deferred checking

foreach my $opt ( @specs ) {
      if ( ref $opt ) { # It's an option spec, not a rule.
         PTDEBUG && _d('Parsing opt spec:',
            map { ($_, '=>', $opt->{$_}) } keys %$opt);

my ( $long, $short ) = $opt->{spec} =~ m/^([\w-]+)(?:\|([^!+=]*))?/;
         if ( !$long ) {
            die "Cannot parse long option from spec $opt->{spec}";
         }
         $opt->{long} = $long;

die "Duplicate long option --$long" if exists $self->{opts}->{$long};
         $self->{opts}->{$long} = $opt;

if ( length $long == 1 ) {
            PTDEBUG && _d('Long opt', $long, 'looks like short opt');
            $self->{short_opts}->{$long} = $long;
         }

if ( $short ) {
            die "Duplicate short option -$short"
               if exists $self->{short_opts}->{$short};
            $self->{short_opts}->{$short} = $long;
            $opt->{short} = $short;
         }
         else {
            $opt->{short} = undef;
         }

$opt->{is_negatable}  = $opt->{spec} =~ m/!/        ? 1 : 0;
         $opt->{is_cumulative} = $opt->{spec} =~ m/\+/       ? 1 : 0;
         $opt->{is_required}   = $opt->{desc} =~ m/required/ ? 1 : 0;

$opt->{group} ||= 'default';
         $self->{groups}->{ $opt->{group} }->{$long} = 1;

$opt->{value} = undef;
         $opt->{got}   = 0;

my ( $type ) = $opt->{spec} =~ m/=(.)/;
         $opt->{type} = $type;
         PTDEBUG && _d($long, 'type:', $type);

$opt->{spec} =~ s/=./=s/ if ( $type && $type =~ m/[HhAadzm]/ );

if ( (my ($def) = $opt->{desc} =~ m/default\b(?: ([^)]+))?/) ) {
            $self->{defaults}->{$long} = defined $def ? $def : 1;
            PTDEBUG && _d($long, 'default:', $def);
         }

if ( $long eq 'config' ) {
            $self->{defaults}->{$long} = join(',', $self->get_defaults_files());
         }

if ( (my ($dis) = $opt->{desc} =~ m/(disables .*)/) ) {
            $disables{$long} = $dis;
            PTDEBUG && _d('Deferring check of disables rule for', $opt, $dis);
         }

$self->{opts}->{$long} = $opt;
      }
      else { # It's an option rule, not a spec.
         PTDEBUG && _d('Parsing rule:', $opt); 
         push @{$self->{rules}}, $opt;
         my @participants = $self->_get_participants($opt);
         my $rule_ok = 0;

if ( $opt =~ m/mutually exclusive|one and only one/ ) {
            $rule_ok = 1;
            push @{$self->{mutex}}, \@participants;
            PTDEBUG && _d(@participants, 'are mutually exclusive');
         }
         if ( $opt =~ m/at least one|one and only one/ ) {
            $rule_ok = 1;
            push @{$self->{atleast1}}, \@participants;
            PTDEBUG && _d(@participants, 'require at least one');
         }
         if ( $opt =~ m/default to/ ) {
            $rule_ok = 1;
            $self->{defaults_to}->{$participants[0]} = $participants[1];
            PTDEBUG && _d($participants[0], 'defaults to', $participants[1]);
         }
         if ( $opt =~ m/restricted to option groups/ ) {
            $rule_ok = 1;
            my ($groups) = $opt =~ m/groups ([\w\s\,]+)/;
            my @groups = split(',', $groups);
            %{$self->{allowed_groups}->{$participants[0]}} = map {
               s/\s+//;
               $_ => 1;
            } @groups;
         }
         if( $opt =~ m/accepts additional command-line arguments/ ) {
            $rule_ok = 1;
            $self->{strict} = 0;
            PTDEBUG && _d("Strict mode disabled by rule");
         }

die "Unrecognized option rule: $opt" unless $rule_ok;
      }
   }

foreach my $long ( keys %disables ) {
      my @participants = $self->_get_participants($disables{$long});
      $self->{disables}->{$long} = \@participants;
      PTDEBUG && _d('Option', $long, 'disables', @participants);
   }

return; 
}

sub _get_participants {
   my ( $self, $str ) = @_;
   my @participants;
   foreach my $long ( $str =~ m/--(?:\[no\])?([\w-]+)/g ) {
      die "Option --$long does not exist while processing rule $str"
         unless exists $self->{opts}->{$long};
      push @participants, $long;
   }
   PTDEBUG && _d('Participants for', $str, ':', @participants);
   return @participants;
}

sub opts {
   my ( $self ) = @_;
   my %opts = %{$self->{opts}};
   return %opts;
}

sub short_opts {
   my ( $self ) = @_;
   my %short_opts = %{$self->{short_opts}};
   return %short_opts;
}

sub set_defaults {
   my ( $self, %defaults ) = @_;
   $self->{defaults} = {};
   foreach my $long ( keys %defaults ) {
      die "Cannot set default for nonexistent option $long"
         unless exists $self->{opts}->{$long};
      $self->{defaults}->{$long} = $defaults{$long};
      PTDEBUG && _d('Default val for', $long, ':', $defaults{$long});
   }
   return;
}

sub get_defaults {
   my ( $self ) = @_;
   return $self->{defaults};
}

sub get_groups {
   my ( $self ) = @_;
   return $self->{groups};
}

sub _set_option {
   my ( $self, $opt, $val ) = @_;
   my $long = exists $self->{opts}->{$opt}       ? $opt
            : exists $self->{short_opts}->{$opt} ? $self->{short_opts}->{$opt}
            : die "Getopt::Long gave a nonexistent option: $opt";
   $opt = $self->{opts}->{$long};
   if ( $opt->{is_cumulative} ) {
      $opt->{value}++;
   }
   elsif ( ($opt->{type} || '') eq 's' && $val =~ m/^--?(.+)/ ) {
      my $next_opt = $1;
      if (    exists $self->{opts}->{$next_opt}
           || exists $self->{short_opts}->{$next_opt} ) {
         $self->save_error("--$long requires a string value");
         return;
      }
      else {
         $opt->{value} = $val;
      }
   }
   else {
      $opt->{value} = $val;
   }
   $opt->{got} = 1;
   PTDEBUG && _d('Got option', $long, '=', $val);
}

sub get_opts {
   my ( $self ) = @_;

foreach my $long ( keys %{$self->{opts}} ) {
      $self->{opts}->{$long}->{got} = 0;
      $self->{opts}->{$long}->{value}
         = exists $self->{defaults}->{$long}       ? $self->{defaults}->{$long}
         : $self->{opts}->{$long}->{is_cumulative} ? 0
         : undef;
   }
   $self->{got_opts} = 0;

$self->{errors} = [];

if ( @ARGV && $ARGV[0] eq "--config" ) {
      shift @ARGV;
      $self->_set_option('config', shift @ARGV);
   }
   if ( $self->has('config') ) {
      my @extra_args;
      foreach my $filename ( split(',', $self->get('config')) ) {
         eval {
            push @extra_args, $self->_read_config_file($filename);
         };
         if ( $EVAL_ERROR ) {
            if ( $self->got('config') ) {
               die $EVAL_ERROR;
            }
            elsif ( PTDEBUG ) {
               _d($EVAL_ERROR);
            }
         }
      }
      unshift @ARGV, @extra_args;
   }

Getopt::Long::Configure('no_ignore_case', 'bundling');
   GetOptions(
      map    { $_->{spec} => sub { $self->_set_option(@_); } }
      grep   { $_->{long} ne 'config' } # --config is handled specially above.
      values %{$self->{opts}}
   ) or $self->save_error('Error parsing options');

if ( exists $self->{opts}->{version} && $self->{opts}->{version}->{got} ) {
      if ( $self->{version} ) {
         print $self->{version}, "\n";
      }
      else {
         print "Error parsing version.  See the VERSION section of the tool's documentation.\n";
      }
      exit 1;
   }

if ( @ARGV && $self->{strict} ) {
      $self->save_error("Unrecognized command-line options @ARGV");
   }

foreach my $mutex ( @{$self->{mutex}} ) {
      my @set = grep { $self->{opts}->{$_}->{got} } @$mutex;
      if ( @set > 1 ) {
         my $err = join(', ', map { "--$self->{opts}->{$_}->{long}" }
                      @{$mutex}[ 0 .. scalar(@$mutex) - 2] )
                 . ' and --'.$self->{opts}->{$mutex->[-1]}->{long}
                 . ' are mutually exclusive.';
         $self->save_error($err);
      }
   }

foreach my $required ( @{$self->{atleast1}} ) {
      my @set = grep { $self->{opts}->{$_}->{got} } @$required;
      if ( @set == 0 ) {
         my $err = join(', ', map { "--$self->{opts}->{$_}->{long}" }
                      @{$required}[ 0 .. scalar(@$required) - 2] )
                 .' or --'.$self->{opts}->{$required->[-1]}->{long};
         $self->save_error("Specify at least one of $err");
      }
   }

$self->_check_opts( keys %{$self->{opts}} );
   $self->{got_opts} = 1;
   return;
}

sub _check_opts {
   my ( $self, @long ) = @_;
   my $long_last = scalar @long;
   while ( @long ) {
      foreach my $i ( 0..$#long ) {
         my $long = $long[$i];
         next unless $long;
         my $opt  = $self->{opts}->{$long};
         if ( $opt->{got} ) {
            if ( exists $self->{disables}->{$long} ) {
               my @disable_opts = @{$self->{disables}->{$long}};
               map { $self->{opts}->{$_}->{value} = undef; } @disable_opts;
               PTDEBUG && _d('Unset options', @disable_opts,
                  'because', $long,'disables them');
            }

if ( exists $self->{allowed_groups}->{$long} ) {

my @restricted_groups = grep {
                  !exists $self->{allowed_groups}->{$long}->{$_}
               } keys %{$self->{groups}};

my @restricted_opts;
               foreach my $restricted_group ( @restricted_groups ) {
                  RESTRICTED_OPT:
                  foreach my $restricted_opt (
                     keys %{$self->{groups}->{$restricted_group}} )
                  {
                     next RESTRICTED_OPT if $restricted_opt eq $long;
                     push @restricted_opts, $restricted_opt
                        if $self->{opts}->{$restricted_opt}->{got};
                  }
               }

if ( @restricted_opts ) {
                  my $err;
                  if ( @restricted_opts == 1 ) {
                     $err = "--$restricted_opts[0]";
                  }
                  else {
                     $err = join(', ',
                               map { "--$self->{opts}->{$_}->{long}" }
                               grep { $_ } 
                               @restricted_opts[0..scalar(@restricted_opts) - 2]
                            )
                          . ' or --'.$self->{opts}->{$restricted_opts[-1]}->{long};
                  }
                  $self->save_error("--$long is not allowed with $err");
               }
            }

}
         elsif ( $opt->{is_required} ) { 
            $self->save_error("Required option --$long must be specified");
         }

$self->_validate_type($opt);
         if ( $opt->{parsed} ) {
            delete $long[$i];
         }
         else {
            PTDEBUG && _d('Temporarily failed to parse', $long);
         }
      }

die "Failed to parse options, possibly due to circular dependencies"
         if @long == $long_last;
      $long_last = @long;
   }

return;
}

sub _validate_type {
   my ( $self, $opt ) = @_;
   return unless $opt;

if ( !$opt->{type} ) {
      $opt->{parsed} = 1;
      return;
   }

my $val = $opt->{value};

if ( $val && $opt->{type} eq 'm' ) {  # type time
      PTDEBUG && _d('Parsing option', $opt->{long}, 'as a time value');
      my ( $prefix, $num, $suffix ) = $val =~ m/([+-]?)(\d+)([a-z])?$/;
      if ( !$suffix ) {
         my ( $s ) = $opt->{desc} =~ m/$suffix (.)$/;
         $suffix = $s || 's';
         PTDEBUG && _d('No suffix given; using', $suffix, 'for',
            $opt->{long}, '(value:', $val, ')');
      }
      if ( $suffix =~ m/[smhd]/ ) {
         $val = $suffix eq 's' ? $num            # Seconds
              : $suffix eq 'm' ? $num * 60       # Minutes
              : $suffix eq 'h' ? $num * 3600     # Hours
              :                  $num * 86400;   # Days
         $opt->{value} = ($prefix || '') . $val;
         PTDEBUG && _d('Setting option', $opt->{long}, 'to', $val);
      }
      else {
         $self->save_error("Invalid time suffix for --$opt->{long}");
      }
   }
   elsif ( $val && $opt->{type} eq 'd' ) {  # type DSN
      PTDEBUG && _d('Parsing option', $opt->{long}, 'as a DSN');
      my $prev = {};
      my $from_key = $self->{defaults_to}->{ $opt->{long} };
      if ( $from_key ) {
         PTDEBUG && _d($opt->{long}, 'DSN copies from', $from_key, 'DSN');
         if ( $self->{opts}->{$from_key}->{parsed} ) {
            $prev = $self->{opts}->{$from_key}->{value};
         }
         else {
            PTDEBUG && _d('Cannot parse', $opt->{long}, 'until',
               $from_key, 'parsed');
            return;
         }
      }
      my $defaults = $self->{DSNParser}->parse_options($self);
      $opt->{value} = $self->{DSNParser}->parse($val, $prev, $defaults);
   }
   elsif ( $val && $opt->{type} eq 'z' ) {  # type size
      PTDEBUG && _d('Parsing option', $opt->{long}, 'as a size value');
      $self->_parse_size($opt, $val);
   }
   elsif ( $opt->{type} eq 'H' || (defined $val && $opt->{type} eq 'h') ) {
      $opt->{value} = { map { $_ => 1 } split(/(?<!\\),\s*/, ($val || '')) };
   }
   elsif ( $opt->{type} eq 'A' || (defined $val && $opt->{type} eq 'a') ) {
      $opt->{value} = [ split(/(?<!\\),\s*/, ($val || '')) ];
   }
   else {
      PTDEBUG && _d('Nothing to validate for option',
         $opt->{long}, 'type', $opt->{type}, 'value', $val);
   }

$opt->{parsed} = 1;
   return;
}

sub get {
   my ( $self, $opt ) = @_;
   my $long = (length $opt == 1 ? $self->{short_opts}->{$opt} : $opt);
   die "Option $opt does not exist"
      unless $long && exists $self->{opts}->{$long};
   return $self->{opts}->{$long}->{value};
}

sub got {
   my ( $self, $opt ) = @_;
   my $long = (length $opt == 1 ? $self->{short_opts}->{$opt} : $opt);
   die "Option $opt does not exist"
      unless $long && exists $self->{opts}->{$long};
   return $self->{opts}->{$long}->{got};
}

sub has {
   my ( $self, $opt ) = @_;
   my $long = (length $opt == 1 ? $self->{short_opts}->{$opt} : $opt);
   return defined $long ? exists $self->{opts}->{$long} : 0;
}

sub set {
   my ( $self, $opt, $val ) = @_;
   my $long = (length $opt == 1 ? $self->{short_opts}->{$opt} : $opt);
   die "Option $opt does not exist"
      unless $long && exists $self->{opts}->{$long};
   $self->{opts}->{$long}->{value} = $val;
   return;
}

sub save_error {
   my ( $self, $error ) = @_;
   push @{$self->{errors}}, $error;
   return;
}

sub errors {
   my ( $self ) = @_;
   return $self->{errors};
}

sub usage {
   my ( $self ) = @_;
   warn "No usage string is set" unless $self->{usage}; # XXX
   return "Usage: " . ($self->{usage} || '') . "\n";
}

sub descr {
   my ( $self ) = @_;
   warn "No description string is set" unless $self->{description}; # XXX
   my $descr  = ($self->{description} || $self->{program_name} || '')
              . "  For more details, please use the --help option, "
              . "or try 'perldoc $PROGRAM_NAME' "
              . "for complete documentation.";
   $descr = join("\n", $descr =~ m/(.{0,80})(?:\s+|$)/g)
      unless $ENV{DONT_BREAK_LINES};
   $descr =~ s/ +$//mg;
   return $descr;
}

sub usage_or_errors {
   my ( $self, $file, $return ) = @_;
   $file ||= $self->{file} || __FILE__;

if ( !$self->{description} || !$self->{usage} ) {
      PTDEBUG && _d("Getting description and usage from SYNOPSIS in", $file);
      my %synop = $self->_parse_synopsis($file);
      $self->{description} ||= $synop{description};
      $self->{usage}       ||= $synop{usage};
      PTDEBUG && _d("Description:", $self->{description},
         "\nUsage:", $self->{usage});
   }

if ( $self->{opts}->{help}->{got} ) {
      print $self->print_usage() or die "Cannot print usage: $OS_ERROR";
      exit 0 unless $return;
   }
   elsif ( scalar @{$self->{errors}} ) {
      print $self->print_errors() or die "Cannot print errors: $OS_ERROR";
      exit 1 unless $return;
   }

return;
}

sub print_errors {
   my ( $self ) = @_;
   my $usage = $self->usage() . "\n";
   if ( (my @errors = @{$self->{errors}}) ) {
      $usage .= join("\n  * ", 'Errors in command-line arguments:', @errors)
              . "\n";
   }
   return $usage . "\n" . $self->descr();
}

sub print_usage {
   my ( $self ) = @_;
   die "Run get_opts() before print_usage()" unless $self->{got_opts};
   my @opts = values %{$self->{opts}};

my $maxl = max(
      map {
         length($_->{long})               # option long name
         + ($_->{is_negatable} ? 4 : 0)   # "[no]" if opt is negatable
         + ($_->{type} ? 2 : 0)           # "=x" where x is the opt type
      }
      @opts);

my $maxs = max(0,
      map {
         length($_)
         + ($self->{opts}->{$_}->{is_negatable} ? 4 : 0)
         + ($self->{opts}->{$_}->{type} ? 2 : 0)
      }
      values %{$self->{short_opts}});

my $lcol = max($maxl, ($maxs + 3));
   my $rcol = 80 - $lcol - 6;
   my $rpad = ' ' x ( 80 - $rcol );

$maxs = max($lcol - 3, $maxs);

my $usage = $self->descr() . "\n" . $self->usage();

my @groups = reverse sort grep { $_ ne 'default'; } keys %{$self->{groups}};
   push @groups, 'default';

foreach my $group ( reverse @groups ) {
      $usage .= "\n".($group eq 'default' ? 'Options' : $group).":\n\n";
      foreach my $opt (
         sort { $a->{long} cmp $b->{long} }
         grep { $_->{group} eq $group }
         @opts )
      {
         my $long  = $opt->{is_negatable} ? "[no]$opt->{long}" : $opt->{long};
         my $short = $opt->{short};
         my $desc  = $opt->{desc};

$long .= $opt->{type} ? "=$opt->{type}" : "";

if ( $opt->{type} && $opt->{type} eq 'm' ) {
            my ($s) = $desc =~ m/$suffix (.)$/;
            $s    ||= 's';
            $desc =~ s/\s+$suffix .$//;
            $desc .= ".  Optional suffix s=seconds, m=minutes, h=hours, "
                   . "d=days; if no suffix, $s is used.";
         }
         $desc = join("\n$rpad", grep { $_ } $desc =~ m/(.{0,$rcol}(?!\W))(?:\s+|(?<=\W)|$)/g);
         $desc =~ s/ +$//mg;
         if ( $short ) {
            $usage .= sprintf("  --%-${maxs}s -%s  %s\n", $long, $short, $desc);
         }
         else {
            $usage .= sprintf("  --%-${lcol}s  %s\n", $long, $desc);
         }
      }
   }

$usage .= "\nOption types: s=string, i=integer, f=float, h/H/a/A=comma-separated list, d=DSN, z=size, m=time\n";

if ( (my @rules = @{$self->{rules}}) ) {
      $usage .= "\nRules:\n\n";
      $usage .= join("\n", map { "  $_" } @rules) . "\n";
   }
   if ( $self->{DSNParser} ) {
      $usage .= "\n" . $self->{DSNParser}->usage();
   }
   $usage .= "\nOptions and values after processing arguments:\n\n";
   foreach my $opt ( sort { $a->{long} cmp $b->{long} } @opts ) {
      my $val   = $opt->{value};
      my $type  = $opt->{type} || '';
      my $bool  = $opt->{spec} =~ m/^[\w-]+(?:\|[\w-])?!?$/;
      $val      = $bool              ? ( $val ? 'TRUE' : 'FALSE' )
                : !defined $val      ? '(No value)'
                : $type eq 'd'       ? $self->{DSNParser}->as_string($val)
                : $type =~ m/H|h/    ? join(',', sort keys %$val)
                : $type =~ m/A|a/    ? join(',', @$val)
                :                    $val;
      $usage .= sprintf("  --%-${lcol}s  %s\n", $opt->{long}, $val);
   }
   return $usage;
}

sub prompt_noecho {
   shift @_ if ref $_[0] eq __PACKAGE__;
   my ( $prompt ) = @_;
   local $OUTPUT_AUTOFLUSH = 1;
   print STDERR $prompt
      or die "Cannot print: $OS_ERROR";
   my $response;
   eval {
      require Term::ReadKey;
      Term::ReadKey::ReadMode('noecho');
      chomp($response = <STDIN>);
      Term::ReadKey::ReadMode('normal');
      print "\n"
         or die "Cannot print: $OS_ERROR";
   };
   if ( $EVAL_ERROR ) {
      die "Cannot read response; is Term::ReadKey installed? $EVAL_ERROR";
   }
   return $response;
}

sub _read_config_file {
   my ( $self, $filename ) = @_;
   open my $fh, "<", $filename or die "Cannot open $filename: $OS_ERROR\n";
   my @args;
   my $prefix = '--';
   my $parse  = 1;

LINE:
   while ( my $line = <$fh> ) {
      chomp $line;
      next LINE if $line =~ m/^\s*(?:\#|\;|$)/;
      $line =~ s/\s+#.*$//g;
      $line =~ s/^\s+|\s+$//g;
      if ( $line eq '--' ) {
         $prefix = '';
         $parse  = 0;
         next LINE;
      }
      if ( $parse
         && (my($opt, $arg) = $line =~ m/^\s*([^=\s]+?)(?:\s*=\s*(.*?)\s*)?$/)
      ) {
         push @args, grep { defined $_ } ("$prefix$opt", $arg);
      }
      elsif ( $line =~ m/./ ) {
         push @args, $line;
      }
      else {
         die "Syntax error in file $filename at line $INPUT_LINE_NUMBER";
      }
   }
   close $fh;
   return @args;
}

sub read_para_after {
   my ( $self, $file, $regex ) = @_;
   open my $fh, "<", $file or die "Can't open $file: $OS_ERROR";
   local $INPUT_RECORD_SEPARATOR = '';
   my $para;
   while ( $para = <$fh> ) {
      next unless $para =~ m/^=pod$/m;
      last;
   }
   while ( $para = <$fh> ) {
      next unless $para =~ m/$regex/;
      last;
   }
   $para = <$fh>;
   chomp($para);
   close $fh or die "Can't close $file: $OS_ERROR";
   return $para;
}

sub clone {
   my ( $self ) = @_;

my %clone = map {
      my $hashref  = $self->{$_};
      my $val_copy = {};
      foreach my $key ( keys %$hashref ) {
         my $ref = ref $hashref->{$key};
         $val_copy->{$key} = !$ref           ? $hashref->{$key}
                           : $ref eq 'HASH'  ? { %{$hashref->{$key}} }
                           : $ref eq 'ARRAY' ? [ @{$hashref->{$key}} ]
                           : $hashref->{$key};
      }
      $_ => $val_copy;
   } qw(opts short_opts defaults);

foreach my $scalar ( qw(got_opts) ) {
      $clone{$scalar} = $self->{$scalar};
   }

return bless \%clone;     
}

sub _parse_size {
   my ( $self, $opt, $val ) = @_;

if ( lc($val || '') eq 'null' ) {
      PTDEBUG && _d('NULL size for', $opt->{long});
      $opt->{value} = 'null';
      return;
   }

my %factor_for = (k => 1_024, M => 1_048_576, G => 1_073_741_824);
   my ($pre, $num, $factor) = $val =~ m/^([+-])?(\d+)([kMG])?$/;
   if ( defined $num ) {
      if ( $factor ) {
         $num *= $factor_for{$factor};
         PTDEBUG && _d('Setting option', $opt->{y},
            'to num', $num, '* factor', $factor);
      }
      $opt->{value} = ($pre || '') . $num;
   }
   else {
      $self->save_error("Invalid size for --$opt->{long}: $val");
   }
   return;
}

sub _parse_attribs {
   my ( $self, $option, $attribs ) = @_;
   my $types = $self->{types};
   return $option
      . ($attribs->{'short form'} ? '|' . $attribs->{'short form'}   : '' )
      . ($attribs->{'negatable'}  ? '!'                              : '' )
      . ($attribs->{'cumulative'} ? '+'                              : '' )
      . ($attribs->{'type'}       ? '=' . $types->{$attribs->{type}} : '' );
}

sub _parse_synopsis {
   my ( $self, $file ) = @_;
   $file ||= $self->{file} || __FILE__;
   PTDEBUG && _d("Parsing SYNOPSIS in", $file);

local $INPUT_RECORD_SEPARATOR = '';  # read paragraphs
   open my $fh, "<", $file or die "Cannot open $file: $OS_ERROR";
   my $para;
   1 while defined($para = <$fh>) && $para !~ m/^=head1 SYNOPSIS/;
   die "$file does not contain a SYNOPSIS section" unless $para;
   my @synop;
   for ( 1..2 ) {  # 1 for the usage, 2 for the description
      my $para = <$fh>;
      push @synop, $para;
   }
   close $fh;
   PTDEBUG && _d("Raw SYNOPSIS text:", @synop);
   my ($usage, $desc) = @synop;
   die "The SYNOPSIS section in $file is not formatted properly"
      unless $usage && $desc;

$usage =~ s/^\s*Usage:\s+(.+)/$1/;
   chomp $usage;

$desc =~ s/\n/ /g;
   $desc =~ s/\s{2,}/ /g;
   $desc =~ s/\. ([A-Z][a-z])/.  $1/g;
   $desc =~ s/\s+$//;

return (
      description => $desc,
      usage       => $usage,
   );
};

sub set_vars {
   my ($self, $file) = @_;
   $file ||= $self->{file} || __FILE__;

my %user_vars;
   my $user_vars = $self->has('set-vars') ? $self->get('set-vars') : undef;
   if ( $user_vars ) {
      foreach my $var_val ( @$user_vars ) {
         my ($var, $val) = $var_val =~ m/([^\s=]+)=(\S+)/;
         die "Invalid --set-vars value: $var_val\n" unless $var && defined $val;
         $user_vars{$var} = {
            val     => $val,
            default => 0,
         };
      }
   }

my %default_vars;
   my $default_vars = $self->read_para_after($file, qr/MAGIC_set_vars/);
   if ( $default_vars ) {
      %default_vars = map {
         my $var_val = $_;
         my ($var, $val) = $var_val =~ m/([^\s=]+)=(\S+)/;
         die "Invalid --set-vars value: $var_val\n" unless $var && defined $val;
         $var => {
            val     => $val,
            default => 1,
         };
      } split("\n", $default_vars);
   }

my %vars = (
      %default_vars, # first the tool's defaults
      %user_vars,    # then the user's which overwrite the defaults
   );
   PTDEBUG && _d('--set-vars:', Dumper(\%vars));
   return \%vars;
}

if ( PTDEBUG ) {
   print STDERR '# ', $^X, ' ', $], "\n";
   if ( my $uname = `uname -a` ) {
      $uname =~ s/\s+/ /g;
      print STDERR "# $uname\n";
   }
   print STDERR '# Arguments: ',
      join(' ', map { my $a = "_[$_]_"; $a =~ s/\n/\n# /g; $a; } @ARGV), "\n";
}

1;
}
# ###########################################################################
# End OptionParser package
# ###########################################################################

# ###########################################################################
# PodParser package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/PodParser.pm
#   t/lib/PodParser.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package PodParser;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

my %parse_items_from = (
   'OPTIONS'     => 1,
   'DSN OPTIONS' => 1,
   'RULES'       => 1,
);

my %item_pattern_for = (
   'OPTIONS'     => qr/--(.*)/,
   'DSN OPTIONS' => qr/\* (.)/,
   'RULES'       => qr/(.*)/,
);

my %section_has_rules = (
   'OPTIONS'     => 1,
   'DSN OPTIONS' => 0,
   'RULES'       => 0,
);

sub new {
   my ( $class, %args ) = @_;
   my $self = {
      current_section => '',
      current_item    => '',
      items           => {},  # keyed off SECTION
      magic           => {},  # keyed off SECTION->magic ident (without MAGIC_)
      magic_ident     => '',  # set when next para is a magic para
   };
   return bless $self, $class;
}
 
sub get_items {
   my ( $self, $section ) = @_;
   return $section ? $self->{items}->{$section} : $self->{items};
}

sub get_magic {
   my ( $self, $section ) = @_;
   return $section ? $self->{magic}->{$section} : $self->{magic};
}

sub parse_from_file {
   my ( $self, $file ) = @_;
   return unless $file;
   PTDEBUG && _d('Parsing POD in', $file);
   open my $fh, "<", $file or die "Cannot open $file: $OS_ERROR";
   local $INPUT_RECORD_SEPARATOR = '';  # read paragraphs
   my $para;

1 while defined($para = <$fh>) && $para !~ m/^=pod/;
   die "$file does not contain =pod" unless $para;

while ( defined($para = <$fh>) && $para !~ m/^=cut/ ) {
      if ( $para =~ m/^=(head|item|over|back)/ ) {
         my ($cmd, $name) = $para =~ m/^=(\w+)(?:\s+(.+))?/;
         $name ||= '';
         PTDEBUG && _d('cmd:', $cmd, 'name:', $name);
         $self->command($cmd, $name);
      }
      elsif ( $parse_items_from{$self->{current_section}} ) {
         $self->textblock($para);
      }
   }

close $fh;
}

sub command {
   my ( $self, $cmd, $name ) = @_;
   
   $name =~ s/\s+\Z//m;  # Remove \n and blank line after name.

if  ( $cmd eq 'head1' ) {
      PTDEBUG && _d('In section', $name);
      $self->{current_section} = $name;
   }
   elsif ( $cmd eq 'over' ) {
      if ( $parse_items_from{$name} ) {
         PTDEBUG && _d('Start items in', $self->{current_section});
         $self->{items}->{$self->{current_section}} = {};
      }
   }
   elsif ( $cmd eq 'item' && $parse_items_from{$self->{current_section}} ) {
      my $pat = $item_pattern_for{ $self->{current_section} };
      my ($item) = $name =~ m/$pat/;
      if ( $item ) {
         PTDEBUG && _d($self->{current_section}, 'item:', $item);
         $self->{items}->{ $self->{current_section} }->{$item} = {
            desc => '',  # every item should have a desc
         };
         $self->{current_item} = $item;
      }
      else {
         warn "Item $name does not match $pat";
      }
   }
   elsif ( $cmd eq 'back' ) {
      if ( $parse_items_from{$self->{current_section}} ) {
         PTDEBUG && _d('End items in', $self->{current_section});
      }
   }
   else {
      $self->{current_section} = '';
   }
   
   return;
}

sub textblock {
   my ( $self, $para ) = @_;

return unless $self->{current_section} && $self->{current_item};

my $section = $self->{current_section};
   my $item    = $self->{items}->{$section}->{ $self->{current_item} };

$para =~ s/\s+\Z//;

if ( $para =~ m/^[a-z]\w+[:;] / ) {
      PTDEBUG && _d('Item attributes:', $para);
      map {
         my ($attrib, $val) = split(/: /, $_);
         $item->{$attrib} = defined $val ? $val : 1;
      } split(/; /, $para);
   }
   else {
      if ( $self->{magic_ident} ) {

my ($leading_space) = $para =~ m/^(\s+)/;
         my $indent          = length($leading_space || '');
         if ( $indent ) {
            $para =~ s/^\s{$indent}//mg;
            $para =~ s/\s+$//;
            PTDEBUG && _d("MAGIC", $self->{magic_ident}, "para:", $para);
            $self->{magic}->{$self->{current_section}}->{$self->{magic_ident}}
               = $para;
         }
         else {
            PTDEBUG && _d("MAGIC", $self->{magic_ident},
               "para is not indented; treating as normal para");
         }

$self->{magic_ident} = '';  # must unset this!
      }

PTDEBUG && _d('Item desc:', substr($para, 0, 40),
         length($para) > 40 ? '...' : '');
      $para =~ s/\n+/ /g;
      $item->{desc} .= $para;

if ( $para =~ m/MAGIC_(\w+)/ ) {
         $self->{magic_ident} = $1;  # XXX
         PTDEBUG && _d("MAGIC", $self->{magic_ident}, "follows");
      }
   }

return;
}

sub verbatim {
   my ( $self, $para ) = @_;
   return;
}

1;
}
# ###########################################################################
# End PodParser package
# ###########################################################################

# ###########################################################################
# QueryParser package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/QueryParser.pm
#   t/lib/QueryParser.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package QueryParser;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

our $tbl_ident = qr/(?:`[^`]+`|\w+)(?:\.(?:`[^`]+`|\w+))?/;
our $tbl_regex = qr{
         \b(?:FROM|JOIN|(?<!KEY\s)UPDATE|INTO) # Words that precede table names
         \b\s*
         \(?                                   # Optional paren around tables
         ($tbl_ident
            (?: (?:\s+ (?:AS\s+)? \w+)?, \s*$tbl_ident )*
         )
      }xio;
our $has_derived = qr{
      \b(?:FROM|JOIN|,)
      \s*\(\s*SELECT
   }xi;

our $data_def_stmts = qr/(?:CREATE|ALTER|TRUNCATE|DROP|RENAME)/i;

our $data_manip_stmts = qr/(?:INSERT|UPDATE|DELETE|REPLACE)/i;

sub new {
   my ( $class ) = @_;
   bless {}, $class;
}

sub get_tables {
   my ( $self, $query ) = @_;
   return unless $query;
   PTDEBUG && _d('Getting tables for', $query);

my ( $ddl_stmt ) = $query =~ m/^\s*($data_def_stmts)\b/i;
   if ( $ddl_stmt ) {
      PTDEBUG && _d('Special table type:', $ddl_stmt);
      $query =~ s/IF\s+(?:NOT\s+)?EXISTS//i;
      if ( $query =~ m/$ddl_stmt DATABASE\b/i ) {
         PTDEBUG && _d('Query alters a database, not a table');
         return ();
      }
      if ( $ddl_stmt =~ m/CREATE/i && $query =~ m/$ddl_stmt\b.+?\bSELECT\b/i ) {
         my ($select) = $query =~ m/\b(SELECT\b.+)/is;
         PTDEBUG && _d('CREATE TABLE ... SELECT:', $select);
         return $self->get_tables($select);
      }
      my ($tbl) = $query =~ m/TABLE\s+($tbl_ident)(\s+.*)?/i;
      PTDEBUG && _d('Matches table:', $tbl);
      return ($tbl);
   }

$query =~ s/ (?:LOW_PRIORITY|IGNORE|STRAIGHT_JOIN)//ig;

if ( $query =~ s/^\s*LOCK TABLES\s+//i ) {
      PTDEBUG && _d('Special table type: LOCK TABLES');
      $query =~ s/\s+(?:READ(?:\s+LOCAL)?|WRITE)\s*//gi;
      PTDEBUG && _d('Locked tables:', $query);
      $query = "FROM $query";
   }

$query =~ s/\\["']//g;                # quoted strings
   $query =~ s/".*?"/?/sg;               # quoted strings
   $query =~ s/'.*?'/?/sg;               # quoted strings

my @tables;
   foreach my $tbls ( $query =~ m/$tbl_regex/gio ) {
      PTDEBUG && _d('Match tables:', $tbls);

next if $tbls =~ m/\ASELECT\b/i;

foreach my $tbl ( split(',', $tbls) ) {
         $tbl =~ s/\s*($tbl_ident)(\s+.*)?/$1/gio;

if ( $tbl !~ m/[a-zA-Z]/ ) {
            PTDEBUG && _d('Skipping suspicious table name:', $tbl);
            next;
         }

push @tables, $tbl;
      }
   }
   return @tables;
}

sub has_derived_table {
   my ( $self, $query ) = @_;
   my $match = $query =~ m/$has_derived/;
   PTDEBUG && _d($query, 'has ' . ($match ? 'a' : 'no') . ' derived table');
   return $match;
}

sub get_aliases {
   my ( $self, $query, $list ) = @_;

my $result = {
      DATABASE => {},
      TABLE    => {},
   };
   return $result unless $query;

$query =~ s/ (?:LOW_PRIORITY|IGNORE|STRAIGHT_JOIN)//ig;

my @tbl_refs;
   my ($tbl_refs, $from) = $query =~ m{
      (
         (FROM|INTO|UPDATE)\b\s*   # Keyword before table refs
         .+?                       # Table refs
      )
      (?:\s+|\z)                   # If the query does not end with the table
      (?:WHERE|ORDER|LIMIT|HAVING|SET|VALUES|\z) # Keyword after table refs
   }ix;

if ( $tbl_refs ) {

if ( $query =~ m/^(?:INSERT|REPLACE)/i ) {
         $tbl_refs =~ s/$[^$]+\)\s*//;
      }

PTDEBUG && _d('tbl refs:', $tbl_refs);

my $before_tbl = qr/(?:,|JOIN|\s|$from)+/i;

my $after_tbl  = qr/(?:,|JOIN|ON|USING|\z)/i;

$tbl_refs =~ s/ = /=/g;

while (
         $tbl_refs =~ m{
            $before_tbl\b\s*
               ( ($tbl_ident) (?:\s+ (?:AS\s+)? (\w+))? )
            \s*$after_tbl
         }xgio )
      {
         my ( $tbl_ref, $db_tbl, $alias ) = ($1, $2, $3);
         PTDEBUG && _d('Match table:', $tbl_ref);
         push @tbl_refs, $tbl_ref;
         $alias = $self->trim_identifier($alias);

if ( $tbl_ref =~ m/^AS\s+\w+/i ) {
            PTDEBUG && _d('Subquery', $tbl_ref);
            $result->{TABLE}->{$alias} = undef;
            next;
         }

my ( $db, $tbl ) = $db_tbl =~ m/^(?:(.*?)\.)?(.*)/;
         $db  = $self->trim_identifier($db);
         $tbl = $self->trim_identifier($tbl);
         $result->{TABLE}->{$alias || $tbl} = $tbl;
         $result->{DATABASE}->{$tbl}        = $db if $db;
      }
   }
   else {
      PTDEBUG && _d("No tables ref in", $query);
   }

if ( $list ) {
      return \@tbl_refs;
   }
   else {
      return $result;
   }
}

sub split {
   my ( $self, $query ) = @_;
   return unless $query;
   $query = $self->clean_query($query);
   PTDEBUG && _d('Splitting', $query);

my $verbs = qr{SELECT|INSERT|UPDATE|DELETE|REPLACE|UNION|CREATE}i;

my @split_statements = grep { $_ } split(m/\b($verbs\b(?!(?:\s*\()))/io, $query);

my @statements;
   if ( @split_statements == 1 ) {
      push @statements, $query;
   }
   else {
      for ( my $i = 0; $i <= $#split_statements; $i += 2 ) {
         push @statements, $split_statements[$i].$split_statements[$i+1];

if ( $statements[-2] && $statements[-2] =~ m/on duplicate key\s+$/i ) {
            $statements[-2] .= pop @statements;
         }
      }
   }

PTDEBUG && _d('statements:', map { $_ ? "<$_>" : 'none' } @statements);
   return @statements;
}

sub clean_query {
   my ( $self, $query ) = @_;
   return unless $query;
   $query =~ s!/\*.*?\*/! !g;  # Remove /* comment blocks */
   $query =~ s/^\s+//;         # Remove leading spaces
   $query =~ s/\s+$//;         # Remove trailing spaces
   $query =~ s/\s{2,}/ /g;     # Remove extra spaces
   return $query;
}

sub split_subquery {
   my ( $self, $query ) = @_;
   return unless $query;
   $query = $self->clean_query($query);
   $query =~ s/;$//;

my @subqueries;
   my $sqno = 0;  # subquery number
   my $pos  = 0;
   while ( $query =~ m/(\S+)(?:\s+|\Z)/g ) {
      $pos = pos($query);
      my $word = $1;
      PTDEBUG && _d($word, $sqno);
      if ( $word =~ m/^\(?SELECT\b/i ) {
         my $start_pos = $pos - length($word) - 1;
         if ( $start_pos ) {
            $sqno++;
            PTDEBUG && _d('Subquery', $sqno, 'starts at', $start_pos);
            $subqueries[$sqno] = {
               start_pos => $start_pos,
               end_pos   => 0,
               len       => 0,
               words     => [$word],
               lp        => 1, # left parentheses
               rp        => 0, # right parentheses
               done      => 0,
            };
         }
         else {
            PTDEBUG && _d('Main SELECT at pos 0');
         }
      }
      else {
         next unless $sqno;  # next unless we're in a subquery
         PTDEBUG && _d('In subquery', $sqno);
         my $sq = $subqueries[$sqno];
         if ( $sq->{done} ) {
            PTDEBUG && _d('This subquery is done; SQL is for',
               ($sqno - 1 ? "subquery $sqno" : "the main SELECT"));
            next;
         }
         push @{$sq->{words}}, $word;
         my $lp = ($word =~ tr/$//) || 0;
         my $rp = ($word =~ tr/$//) || 0;
         PTDEBUG && _d('parentheses left', $lp, 'right', $rp);
         if ( ($sq->{lp} + $lp) - ($sq->{rp} + $rp) == 0 ) {
            my $end_pos = $pos - 1;
            PTDEBUG && _d('Subquery', $sqno, 'ends at', $end_pos);
            $sq->{end_pos} = $end_pos;
            $sq->{len}     = $end_pos - $sq->{start_pos};
         }
      }
   }

for my $i ( 1..$#subqueries ) {
      my $sq = $subqueries[$i];
      next unless $sq;
      $sq->{sql} = join(' ', @{$sq->{words}});
      substr $query,
         $sq->{start_pos} + 1,  # +1 for (
         $sq->{len} - 1,        # -1 for )
         "__subquery_$i";
   }

return $query, map { $_->{sql} } grep { defined $_ } @subqueries;
}

sub query_type {
   my ( $self, $query, $qr ) = @_;
   my ($type, undef) = $qr->distill_verbs($query);
   my $rw;
   if ( $type =~ m/^SELECT\b/ ) {
      $rw = 'read';
   }
   elsif ( $type =~ m/^$data_manip_stmts\b/
           || $type =~ m/^$data_def_stmts\b/  ) {
      $rw = 'write'
   }

return {
      type => $type,
      rw   => $rw,
   }
}

sub get_columns {
   my ( $self, $query ) = @_;
   my $cols = [];
   return $cols unless $query;
   my $cols_def;

if ( $query =~ m/^SELECT/i ) {
      $query =~ s/
         ^SELECT\s+
           (?:ALL
              |DISTINCT
              |DISTINCTROW
              |HIGH_PRIORITY
              |STRAIGHT_JOIN
              |SQL_SMALL_RESULT
              |SQL_BIG_RESULT
              |SQL_BUFFER_RESULT
              |SQL_CACHE
              |SQL_NO_CACHE
              |SQL_CALC_FOUND_ROWS
           )\s+
      /SELECT /xgi;
      ($cols_def) = $query =~ m/^SELECT\s+(.+?)\s+FROM/i;
   }
   elsif ( $query =~ m/^(?:INSERT|REPLACE)/i ) {
      ($cols_def) = $query =~ m/$([^$]+)\)\s*VALUE/i;
   }

PTDEBUG && _d('Columns:', $cols_def);
   if ( $cols_def ) {
      @$cols = split(',', $cols_def);
      map {
         my $col = $_;
         $col = s/^\s+//g;
         $col = s/\s+$//g;
         $col;
      } @$cols;
   }

return $cols;
}

sub parse {
   my ( $self, $query ) = @_;
   return unless $query;
   my $parsed = {};

$query =~ s/\n/ /g;
   $query = $self->clean_query($query);

$parsed->{query}   = $query,
   $parsed->{tables}  = $self->get_aliases($query, 1);
   $parsed->{columns} = $self->get_columns($query);

my ($type) = $query =~ m/^(\w+)/;
   $parsed->{type} = lc $type;

$parsed->{sub_queries} = [];

return $parsed;
}

sub extract_tables {
   my ( $self, %args ) = @_;
   my $query      = $args{query};
   my $default_db = $args{default_db};
   my $q          = $self->{Quoter} || $args{Quoter};
   return unless $query;
   PTDEBUG && _d('Extracting tables');
   my @tables;
   my %seen;
   foreach my $db_tbl ( $self->get_tables($query) ) {
      next unless $db_tbl;
      next if $seen{$db_tbl}++; # Unique-ify for issue 337.
      my ( $db, $tbl ) = $q->split_unquote($db_tbl);
      push @tables, [ $db || $default_db, $tbl ];
   }
   return @tables;
}

sub trim_identifier {
   my ($self, $str) = @_;
   return unless defined $str;
   $str =~ s/`//g;
   $str =~ s/^\s+//;
   $str =~ s/\s+$//;
   return $str;
}

1;
}
# ###########################################################################
# End QueryParser package
# ###########################################################################

# ###########################################################################
# QueryRewriter package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/QueryRewriter.pm
#   t/lib/QueryRewriter.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package QueryRewriter;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

our $verbs   = qr{^SHOW|^FLUSH|^COMMIT|^ROLLBACK|^BEGIN|SELECT|INSERT
                  |UPDATE|DELETE|REPLACE|^SET|UNION|^START|^LOCK}xi;
my $quote_re = qr/"(?:(?!(?<!\\)").)*"|'(?:(?!(?<!\\)').)*'/; # Costly!
my $bal;
$bal         = qr/
                  $
                  (?:
                     (?> [^()]+ )    # Non-parens without backtracking
                     |
                     (??{ $bal })    # Group with matching parens
                  )*
                  $
                 /x;

my $olc_re = qr/(?:--|#)[^'"\r\n]*(?=[\r\n]|\Z)/;  # One-line comments
my $mlc_re = qr#/\*[^!].*?\*/#sm;                  # But not /*!version */
my $vlc_re = qr#/\*.*?[0-9]+.*?\*/#sm;             # For SHOW + /*!version */
my $vlc_rf = qr#^(?:SHOW).*?/\*![0-9]+(.*?)\*/#sm;     # Variation for SHOW

sub new {
   my ( $class, %args ) = @_;
   my $self = { %args };
   return bless $self, $class;
}

sub strip_comments {
   my ( $self, $query ) = @_;
   return unless $query;
   $query =~ s/$mlc_re//go;
   $query =~ s/$olc_re//go;
   if ( $query =~ m/$vlc_rf/i ) { # contains show + version
      my $qualifier = $1 || '';
      $query =~ s/$vlc_re/$qualifier/go;
   }
   return $query;
}

sub shorten {
   my ( $self, $query, $length ) = @_;
   $query =~ s{
      \A(
         (?:INSERT|REPLACE)
         (?:\s+LOW_PRIORITY|DELAYED|HIGH_PRIORITY|IGNORE)?
         (?:\s\w+)*\s+\S+\s+VALUES\s*$.*?$
      )
      \s*,\s*\(.*?(ON\s+DUPLICATE|\Z)}
      {$1 /*... omitted ...*/$2}xsi;

return $query unless $query =~ m/IN\s*\(\s*(?!select)/i;

my $last_length  = 0;
   my $query_length = length($query);
   while (
      $length          > 0
      && $query_length > $length
      && $query_length < ( $last_length || $query_length + 1 )
   ) {
      $last_length = $query_length;
      $query =~ s{
         (\bIN\s*$)    # The opening of an IN list
         ([^$]+)       # Contents of the list, assuming no item contains paren
         (?=\))           # Close of the list
      }
      {
         $1 . __shorten($2)
      }gexsi;
   }

return $query;
}

sub __shorten {
   my ( $snippet ) = @_;
   my @vals = split(/,/, $snippet);
   return $snippet unless @vals > 20;
   my @keep = splice(@vals, 0, 20);  # Remove and save the first 20 items
   return
      join(',', @keep)
      . "/*... omitted "
      . scalar(@vals)
      . " items ...*/";
}

sub fingerprint {
   my ( $self, $query ) = @_;

$query =~ m#\ASELECT /\*!40001 SQL_NO_CACHE \*/ \* FROM `# # mysqldump query
      && return 'mysqldump';
   $query =~ m#/\*\w+\.\w+:[0-9]/[0-9]\*/#     # pt-table-checksum, etc query
      && return 'percona-toolkit';
   $query =~ m/\Aadministrator command: /
      && return $query;
   $query =~ m/\A\s*(call\s+\S+)$/i
      && return lc($1); # Warning! $1 used, be careful.
   if ( my ($beginning) = $query =~ m/\A((?:INSERT|REPLACE)(?: IGNORE)?\s+INTO.+?VALUES\s*\(.*?$)\s*,\s*\(/is ) {
      $query = $beginning; # Shorten multi-value INSERT statements ASAP
   }

$query =~ s/$mlc_re//go;
   $query =~ s/$olc_re//go;
   $query =~ s/\Ause \S+\Z/use ?/i       # Abstract the DB in USE
      && return $query;

$query =~ s/\\["']//g;                # quoted strings
   $query =~ s/".*?"/?/sg;               # quoted strings
   $query =~ s/'.*?'/?/sg;               # quoted strings

$query =~ s/\bfalse\b|\btrue\b/?/isg; # boolean values

if ( $self->{match_md5_checksums} ) { 
      $query =~ s/([._-])[a-f0-9]{32}/$1?/g;
   }

if ( !$self->{match_embedded_numbers} ) {
      $query =~ s/[0-9+-][0-9a-f.xb+-]*/?/g;
   }
   else {
      $query =~ s/\b[0-9+-][0-9a-f.xb+-]*/?/g;
   }

if ( $self->{match_md5_checksums} ) {
      $query =~ s/[xb+-]\?/?/g;                
   }
   else {
      $query =~ s/[xb.+-]\?/?/g;
   }

$query =~ s/\A\s+//;                  # Chop off leading whitespace
   chomp $query;                         # Kill trailing whitespace
   $query =~ tr[ \n\t\r\f][ ]s;          # Collapse whitespace
   $query = lc $query;
   $query =~ s/\bnull\b/?/g;             # Get rid of NULLs
   $query =~ s{                          # Collapse IN and VALUES lists
               \b(in|values?)(?:[\s,]*$[\s?,]*$)+
              }
              {$1(?+)}gx;
   $query =~ s{                          # Collapse UNION
               \b(select\s.*?)(?:(\sunion(?:\sall)?)\s\1)+
              }
              {$1 /*repeat$2*/}xg;
   $query =~ s/\blimit \?(?:, ?\?| offset \?)?/limit ?/; # LIMIT

if ( $query =~ m/\bORDER BY /gi ) {  # Find, anchor on ORDER BY clause
      1 while $query =~ s/\G(.+?)\s+ASC/$1/gi && pos $query;
   }

return $query;
}

sub distill_verbs {
   my ( $self, $query ) = @_;

$query =~ m/\A\s*call\s+(\S+)\(/i && return "CALL $1";
   $query =~ m/\A\s*use\s+/          && return "USE";
   $query =~ m/\A\s*UNLOCK TABLES/i  && return "UNLOCK";
   $query =~ m/\A\s*xa\s+(\S+)/i     && return "XA_$1";

if ( $query =~ m/\A\s*LOAD/i ) {
      my ($tbl) = $query =~ m/INTO TABLE\s+(\S+)/i;
      $tbl ||= '';
      $tbl =~ s/`//g;
      return "LOAD DATA $tbl";
   }

if ( $query =~ m/\Aadministrator command:/ ) {
      $query =~ s/administrator command:/ADMIN/;
      $query = uc $query;
      return $query;
   }

$query = $self->strip_comments($query);

if ( $query =~ m/\A\s*SHOW\s+/i ) {
      PTDEBUG && _d($query);

$query = uc $query;
      $query =~ s/\s+(?:SESSION|FULL|STORAGE|ENGINE)\b/ /g;
      $query =~ s/\s+COUNT[^)]+\)//g;

$query =~ s/\A(SHOW(?:\s+\S+){1,2}).*\Z/$1/s;
      $query =~ s/\s+/ /g;
      PTDEBUG && _d($query);
      return $query;
   }

eval $QueryParser::data_def_stmts;
   eval $QueryParser::tbl_ident;
   my ( $dds ) = $query =~ /^\s*($QueryParser::data_def_stmts)\b/i;
   if ( $dds) {
      $query =~ s/\s+IF(?:\s+NOT)?\s+EXISTS/ /i;
      my ( $obj ) = $query =~ m/$dds.+(DATABASE|TABLE)\b/i;
      $obj = uc $obj if $obj;
      PTDEBUG && _d('Data def statment:', $dds, 'obj:', $obj);
      my ($db_or_tbl)
         = $query =~ m/(?:TABLE|DATABASE)\s+($QueryParser::tbl_ident)(\s+.*)?/i;
      PTDEBUG && _d('Matches db or table:', $db_or_tbl);
      return uc($dds . ($obj ? " $obj" : '')), $db_or_tbl;
   }

my @verbs = $query =~ m/\b($verbs)\b/gio;
   @verbs    = do {
      my $last = '';
      grep { my $pass = $_ ne $last; $last = $_; $pass } map { uc } @verbs;
   };

if ( ($verbs[0] || '') eq 'SELECT' && @verbs > 1 ) {
      PTDEBUG && _d("False-positive verbs after SELECT:", @verbs[1..$#verbs]);
      my $union = grep { $_ eq 'UNION' } @verbs;
      @verbs    = $union ? qw(SELECT UNION) : qw(SELECT);
   }

my $verb_str = join(q{ }, @verbs);
   return $verb_str;
}

sub __distill_tables {
   my ( $self, $query, $table, %args ) = @_;
   my $qp = $args{QueryParser} || $self->{QueryParser};
   die "I need a QueryParser argument" unless $qp;

my @tables = map {
      $_ =~ s/`//g;
      $_ =~ s/(_?)[0-9]+/$1?/g;
      $_;
   } grep { defined $_ } $qp->get_tables($query);

push @tables, $table if $table;

@tables = do {
      my $last = '';
      grep { my $pass = $_ ne $last; $last = $_; $pass } @tables;
   };

return @tables;
}

sub distill {
   my ( $self, $query, %args ) = @_;

if ( $args{generic} ) {
      my ($cmd, $arg) = $query =~ m/^(\S+)\s+(\S+)/;
      return '' unless $cmd;
      $query = (uc $cmd) . ($arg ? " $arg" : '');
   }
   else {
      my ($verbs, $table)  = $self->distill_verbs($query, %args);

if ( $verbs && $verbs =~ m/^SHOW/ ) {
         my %alias_for = qw(
            SCHEMA   DATABASE
            KEYS     INDEX
            INDEXES  INDEX
         );
         map { $verbs =~ s/$_/$alias_for{$_}/ } keys %alias_for;
         $query = $verbs;
      }
      elsif ( $verbs && $verbs =~ m/^LOAD DATA/ ) {
         return $verbs;
      }
      else {
         my @tables = $self->__distill_tables($query, $table, %args);
         $query     = join(q{ }, $verbs, @tables); 
      } 
   }

if ( $args{trf} ) {
      $query = $args{trf}->($query, %args);
   }

return $query;
}

sub convert_to_select {
   my ( $self, $query ) = @_;
   return unless $query;

return if $query =~ m/=\s*\(\s*SELECT /i;

$query =~ s{
                 \A.*?
                 update(?:\s+(?:low_priority|ignore))?\s+(.*?)
                 \s+set\b(.*?)
                 (?:\s*where\b(.*?))?
                 (limit\s*[0-9]+(?:\s*,\s*[0-9]+)?)?
                 \Z
              }
              {__update_to_select($1, $2, $3, $4)}exsi
      || $query =~ s{
                    \A.*?
                    (?:insert(?:\s+ignore)?|replace)\s+
                    .*?\binto\b(.*?)$([^$]+)\)\s*
                    values?\s*($.*?$)\s*
                    (?:\blimit\b|on\s+duplicate\s+key.*)?\s*
                    \Z
                 }
                 {__insert_to_select($1, $2, $3)}exsi
      || $query =~ s{
                    \A.*?
                    (?:insert(?:\s+ignore)?|replace)\s+
                    (?:.*?\binto)\b(.*?)\s*
                    set\s+(.*?)\s*
                    (?:\blimit\b|on\s+duplicate\s+key.*)?\s*
                    \Z
                 }
                 {__insert_to_select_with_set($1, $2)}exsi
      || $query =~ s{
                    \A.*?
                    delete\s+(.*?)
                    \bfrom\b(.*)
                    \Z
                 }
                 {__delete_to_select($1, $2)}exsi;
   $query =~ s/\s*on\s+duplicate\s+key\s+update.*\Z//si;
   $query =~ s/\A.*?(?=\bSELECT\s*\b)//ism;
   return $query;
}

sub convert_select_list {
   my ( $self, $query ) = @_;
   $query =~ s{
               \A\s*select(.*?)\bfrom\b
              }
              {$1 =~ m/\*/ ? "select 1 from" : "select isnull(coalesce($1)) from"}exi;
   return $query;
}

sub __delete_to_select {
   my ( $delete, $join ) = @_;
   if ( $join =~ m/\bjoin\b/ ) {
      return "select 1 from $join";
   }
   return "select * from $join";
}

sub __insert_to_select {
   my ( $tbl, $cols, $vals ) = @_;
   PTDEBUG && _d('Args:', @_);
   my @cols = split(/,/, $cols);
   PTDEBUG && _d('Cols:', @cols);
   $vals =~ s/^$|$$//g; # Strip leading/trailing parens
   my @vals = $vals =~ m/($quote_re|[^,]*${bal}[^,]*|[^,]+)/g;
   PTDEBUG && _d('Vals:', @vals);
   if ( @cols == @vals ) {
      return "select * from $tbl where "
         . join(' and ', map { "$cols[$_]=$vals[$_]" } (0..$#cols));
   }
   else {
      return "select * from $tbl limit 1";
   }
}

sub __insert_to_select_with_set {
   my ( $from, $set ) = @_;
   $set =~ s/,/ and /g;
   return "select * from $from where $set ";
}

sub __update_to_select {
   my ( $from, $set, $where, $limit ) = @_;
   return "select $set from $from "
      . ( $where ? "where $where" : '' )
      . ( $limit ? " $limit "      : '' );
}

sub wrap_in_derived {
   my ( $self, $query ) = @_;
   return unless $query;
   return $query =~ m/\A\s*select/i
      ? "select 1 from ($query) as x limit 1"
      : $query;
}

1;
}
# ###########################################################################
# End QueryRewriter package
# ###########################################################################

# ###########################################################################
# SlowLogParser package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/SlowLogParser.pm
#   t/lib/SlowLogParser.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package SlowLogParser;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
$Data::Dumper::Indent    = 1;
$Data::Dumper::Sortkeys  = 1;
$Data::Dumper::Quotekeys = 0;

sub new {
   my ( $class ) = @_;
   my $self = {
      pending => [],
      last_event_offset => undef,
   };
   return bless $self, $class;
}

my $slow_log_ts_line = qr/^# Time: ([0-9: ]{15})/;
my $slow_log_uh_line = qr/# User\@Host: ([^\[]+|\[[^[]+\]).*?@ (\S*) \[(.*)\]\s*(?:Id:\s*(\d+))?/;
my $slow_log_hd_line = qr{
      ^(?:
      T[cC][pP]\s[pP]ort:\s+\d+ # case differs on windows/unix
      |
      [/A-Z].*mysqld,\sVersion.*(?:started\swith:|embedded\slibrary)
      |
      Time\s+Id\s+Command
      ).*\n
   }xm;

sub parse_event {
   my ( $self, %args ) = @_;
   my @required_args = qw(next_event tell);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }
   my ($next_event, $tell) = @args{@required_args};

my $pending = $self->{pending};
   local $INPUT_RECORD_SEPARATOR = ";\n#";
   my $trimlen    = length($INPUT_RECORD_SEPARATOR);
   my $pos_in_log = $tell->();
   my $stmt;

EVENT:
   while (
         defined($stmt = shift @$pending)
      or defined($stmt = $next_event->())
   ) {
      my @properties = ('cmd', 'Query', 'pos_in_log', $pos_in_log);
      $self->{last_event_offset} = $pos_in_log;
      $pos_in_log = $tell->();

if ( $stmt =~ s/$slow_log_hd_line//go ){ # Throw away header lines in log
         my @chunks = split(/$INPUT_RECORD_SEPARATOR/o, $stmt);
         if ( @chunks > 1 ) {
            PTDEBUG && _d("Found multiple chunks");
            $stmt = shift @chunks;
            unshift @$pending, @chunks;
         }
      }

$stmt = '#' . $stmt unless $stmt =~ m/\A#/;
      $stmt =~ s/;\n#?\Z//;

my ($got_ts, $got_uh, $got_ac, $got_db, $got_set, $got_embed);
      my $pos = 0;
      my $len = length($stmt);
      my $found_arg = 0;
      LINE:
      while ( $stmt =~ m/^(.*)$/mg ) { # /g is important, requires scalar match.
         $pos     = pos($stmt);  # Be careful not to mess this up!
         my $line = $1;          # Necessary for /g and pos() to work.
         PTDEBUG && _d($line);

if ($line =~ m/^(?:#|use |SET (?:last_insert_id|insert_id|timestamp))/o) {

if ( !$got_ts && (my ( $time ) = $line =~ m/$slow_log_ts_line/o)) {
               PTDEBUG && _d("Got ts", $time);
               push @properties, 'ts', $time;
               ++$got_ts;
               if ( !$got_uh
                  && ( my ( $user, $host, $ip, $thread_id ) = $line =~ m/$slow_log_uh_line/o )
               ) {
                  PTDEBUG && _d("Got user, host, ip", $user, $host, $ip);
                  $host ||= $ip;  # sometimes host is missing when using skip-name-resolve (LP #issue 1262456)
                  push @properties, 'user', $user, 'host', $host, 'ip', $ip;
                  if ( $thread_id ) {  
                     push @properties, 'Thread_id', $thread_id;
                 }
                 ++$got_uh;
               }
            }

elsif ( !$got_uh
                  && ( my ( $user, $host, $ip, $thread_id ) = $line =~ m/$slow_log_uh_line/o )
            ) {
                  PTDEBUG && _d("Got user, host, ip", $user, $host, $ip);
                  $host ||= $ip;  # sometimes host is missing when using skip-name-resolve (LP #issue 1262456)
                  push @properties, 'user', $user, 'host', $host, 'ip', $ip;
                  if ( $thread_id ) {       
                     push @properties, 'Thread_id', $thread_id;
                 }
               ++$got_uh;
            }

elsif (!$got_ac && $line =~ m/^# (?:administrator command:.*)$/) {
               PTDEBUG && _d("Got admin command");
               $line =~ s/^#\s+//;  # string leading "# ".
               push @properties, 'cmd', 'Admin', 'arg', $line;
               push @properties, 'bytes', length($properties[-1]);
               ++$found_arg;
               ++$got_ac;
            }

elsif ( $line =~ m/^# +[A-Z][A-Za-z_]+: \S+/ ) { # Make the test cheap!
               PTDEBUG && _d("Got some line with properties");

if ( $line =~ m/Schema:\s+\w+: / ) {
                  PTDEBUG && _d('Removing empty Schema attrib');
                  $line =~ s/Schema:\s+//;
                  PTDEBUG && _d($line);
               }

my @temp = $line =~ m/(\w+):\s+(\S+|\Z)/g;
               push @properties, @temp;
            }

elsif ( !$got_db && (my ( $db ) = $line =~ m/^use ([^;]+)/ ) ) {
               PTDEBUG && _d("Got a default database:", $db);
               push @properties, 'db', $db;
               ++$got_db;
            }

elsif (!$got_set && (my ($setting) = $line =~ m/^SET\s+([^;]*)/)) {
               PTDEBUG && _d("Got some setting:", $setting);
               push @properties, split(/,|\s*=\s*/, $setting);
               ++$got_set;
            }

if ( !$found_arg && $pos == $len ) {
               PTDEBUG && _d("Did not find arg, looking for special cases");
               local $INPUT_RECORD_SEPARATOR = ";\n";  # get next line
               if ( defined(my $l = $next_event->()) ) {
                  if ( $l =~ /^\s*[A-Z][a-z_]+: / ) {
                     PTDEBUG && _d("Found NULL query before", $l);
                     local $INPUT_RECORD_SEPARATOR = ";\n#";
                     my $rest_of_event = $next_event->();
                     push @{$self->{pending}}, $l . $rest_of_event;
                     push @properties, 'cmd', 'Query', 'arg', '/* No query */';
                     push @properties, 'bytes', 0;
                     $found_arg++;
                  }
                  else {
                     chomp $l;
                     $l =~ s/^\s+//;
                     PTDEBUG && _d("Found admin statement", $l);
                     push @properties, 'cmd', 'Admin', 'arg', $l;
                     push @properties, 'bytes', length($properties[-1]);
                     $found_arg++;
                  }
               }
               else {
                  PTDEBUG && _d("I can't figure out what to do with this line");
                  next EVENT;
               }
            }
         }
         else {
            PTDEBUG && _d("Got the query/arg line");
            my $arg = substr($stmt, $pos - length($line));
            push @properties, 'arg', $arg, 'bytes', length($arg);
            if ( $args{misc} && $args{misc}->{embed}
               && ( my ($e) = $arg =~ m/($args{misc}->{embed})/)
            ) {
               push @properties, $e =~ m/$args{misc}->{capture}/g;
            }
            last LINE;
         }
      }

PTDEBUG && _d('Properties of event:', Dumper(\@properties));
      my $event = { @properties };
      if ( !$event->{arg} ) {
         PTDEBUG && _d('Partial event, no arg');
      }
      else {
         $self->{last_event_offset} = undef;
         if ( $args{stats} ) {
            $args{stats}->{events_read}++;
            $args{stats}->{events_parsed}++;
         }
      }
      return $event;
   } # EVENT

@$pending = ();
   $args{oktorun}->(0) if $args{oktorun};
   return;
}

1;
}
# ###########################################################################
# End SlowLogParser package
# ###########################################################################

# ###########################################################################
# TableParser package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/TableParser.pm
#   t/lib/TableParser.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package TableParser;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
$Data::Dumper::Indent    = 1;
$Data::Dumper::Sortkeys  = 1;
$Data::Dumper::Quotekeys = 0;

local $EVAL_ERROR;
eval {
   require Quoter;
};

sub new {
   my ( $class, %args ) = @_;
   my $self = { %args };
   $self->{Quoter} ||= Quoter->new();
   return bless $self, $class;
}

sub Quoter { shift->{Quoter} }

sub get_create_table {
   my ( $self, $dbh, $db, $tbl ) = @_;
   die "I need a dbh parameter" unless $dbh;
   die "I need a db parameter"  unless $db;
   die "I need a tbl parameter" unless $tbl;
   my $q = $self->{Quoter};

my $new_sql_mode
      = q{/*!40101 SET @OLD_SQL_MODE := @@SQL_MODE, }
      . q{@@SQL_MODE := '', }
      . q{@OLD_QUOTE := @@SQL_QUOTE_SHOW_CREATE, }
      . q{@@SQL_QUOTE_SHOW_CREATE := 1 */};

my $old_sql_mode
      = q{/*!40101 SET @@SQL_MODE := @OLD_SQL_MODE, }
      . q{@@SQL_QUOTE_SHOW_CREATE := @OLD_QUOTE */};

PTDEBUG && _d($new_sql_mode);
   eval { $dbh->do($new_sql_mode); };
   PTDEBUG && $EVAL_ERROR && _d($EVAL_ERROR);

my $use_sql = 'USE ' . $q->quote($db);
   PTDEBUG && _d($dbh, $use_sql);
   $dbh->do($use_sql);

my $show_sql = "SHOW CREATE TABLE " . $q->quote($db, $tbl);
   PTDEBUG && _d($show_sql);
   my $href;
   eval { $href = $dbh->selectrow_hashref($show_sql); };
   if ( my $e = $EVAL_ERROR ) {
      PTDEBUG && _d($old_sql_mode);
      $dbh->do($old_sql_mode);

die $e;
   }

PTDEBUG && _d($old_sql_mode);
   $dbh->do($old_sql_mode);

my ($key) = grep { m/create (?:table|view)/i } keys %$href;
   if ( !$key ) {
      die "Error: no 'Create Table' or 'Create View' in result set from "
         . "$show_sql: " . Dumper($href);
   }

return $href->{$key};
}

sub parse {
   my ( $self, $ddl, $opts ) = @_;
   return unless $ddl;

if ( $ddl =~ m/CREATE (?:TEMPORARY )?TABLE "/ ) {
      $ddl = $self->ansi_to_legacy($ddl);
   }
   elsif ( $ddl !~ m/CREATE (?:TEMPORARY )?TABLE `/ ) {
      die "TableParser doesn't handle CREATE TABLE without quoting.";
   }

my ($name)     = $ddl =~ m/CREATE (?:TEMPORARY )?TABLE\s+(`.+?`)/;
   (undef, $name) = $self->{Quoter}->split_unquote($name) if $name;

$ddl =~ s/(`[^`]+`)/\L$1/g;

my $engine = $self->get_engine($ddl);

my @defs   = $ddl =~ m/^(\s+`.*?),?$/gm;
   my @cols   = map { $_ =~ m/`([^`]+)`/ } @defs;
   PTDEBUG && _d('Table cols:', join(', ', map { "`$_`" } @cols));

my %def_for;
   @def_for{@cols} = @defs;

my (@nums, @null);
   my (%type_for, %is_nullable, %is_numeric, %is_autoinc);
   foreach my $col ( @cols ) {
      my $def = $def_for{$col};

$def =~ s/``//g;

my ( $type ) = $def =~ m/`[^`]+`\s([a-z]+)/;
      die "Can't determine column type for $def" unless $type;
      $type_for{$col} = $type;
      if ( $type =~ m/(?:(?:tiny|big|medium|small)?int|float|double|decimal|year)/ ) {
         push @nums, $col;
         $is_numeric{$col} = 1;
      }
      if ( $def !~ m/NOT NULL/ ) {
         push @null, $col;
         $is_nullable{$col} = 1;
      }
      $is_autoinc{$col} = $def =~ m/AUTO_INCREMENT/i ? 1 : 0;
   }

my ($keys, $clustered_key) = $self->get_keys($ddl, $opts, \%is_nullable);

my ($charset) = $ddl =~ m/DEFAULT CHARSET=(\w+)/;

return {
      name           => $name,
      cols           => \@cols,
      col_posn       => { map { $cols[$_] => $_ } 0..$#cols },
      is_col         => { map { $_ => 1 } @cols },
      null_cols      => \@null,
      is_nullable    => \%is_nullable,
      is_autoinc     => \%is_autoinc,
      clustered_key  => $clustered_key,
      keys           => $keys,
      defs           => \%def_for,
      numeric_cols   => \@nums,
      is_numeric     => \%is_numeric,
      engine         => $engine,
      type_for       => \%type_for,
      charset        => $charset,
   };
}

sub sort_indexes {
   my ( $self, $tbl ) = @_;

my @indexes
      = sort {
         (($a ne 'PRIMARY') <=> ($b ne 'PRIMARY'))
         || ( !$tbl->{keys}->{$a}->{is_unique} <=> !$tbl->{keys}->{$b}->{is_unique} )
         || ( $tbl->{keys}->{$a}->{is_nullable} <=> $tbl->{keys}->{$b}->{is_nullable} )
         || ( scalar(@{$tbl->{keys}->{$a}->{cols}}) <=> scalar(@{$tbl->{keys}->{$b}->{cols}}) )
      }
      grep {
         $tbl->{keys}->{$_}->{type} eq 'BTREE'
      }
      sort keys %{$tbl->{keys}};

PTDEBUG && _d('Indexes sorted best-first:', join(', ', @indexes));
   return @indexes;
}

sub find_best_index {
   my ( $self, $tbl, $index ) = @_;
   my $best;
   if ( $index ) {
      ($best) = grep { uc $_ eq uc $index } keys %{$tbl->{keys}};
   }
   if ( !$best ) {
      if ( $index ) {
         die "Index '$index' does not exist in table";
      }
      else {
         ($best) = $self->sort_indexes($tbl);
      }
   }
   PTDEBUG && _d('Best index found is', $best);
   return $best;
}

sub find_possible_keys {
   my ( $self, $dbh, $database, $table, $quoter, $where ) = @_;
   return () unless $where;
   my $sql = 'EXPLAIN SELECT * FROM ' . $quoter->quote($database, $table)
      . ' WHERE ' . $where;
   PTDEBUG && _d($sql);
   my $expl = $dbh->selectrow_hashref($sql);
   $expl = { map { lc($_) => $expl->{$_} } keys %$expl };
   if ( $expl->{possible_keys} ) {
      PTDEBUG && _d('possible_keys =', $expl->{possible_keys});
      my @candidates = split(',', $expl->{possible_keys});
      my %possible   = map { $_ => 1 } @candidates;
      if ( $expl->{key} ) {
         PTDEBUG && _d('MySQL chose', $expl->{key});
         unshift @candidates, grep { $possible{$_} } split(',', $expl->{key});
         PTDEBUG && _d('Before deduping:', join(', ', @candidates));
         my %seen;
         @candidates = grep { !$seen{$_}++ } @candidates;
      }
      PTDEBUG && _d('Final list:', join(', ', @candidates));
      return @candidates;
   }
   else {
      PTDEBUG && _d('No keys in possible_keys');
      return ();
   }
}

sub check_table {
   my ( $self, %args ) = @_;
   my @required_args = qw(dbh db tbl);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }
   my ($dbh, $db, $tbl) = @args{@required_args};
   my $q      = $self->{Quoter} || 'Quoter';
   my $db_tbl = $q->quote($db, $tbl);
   PTDEBUG && _d('Checking', $db_tbl);

my $sql = "SHOW TABLES FROM " . $q->quote($db)
           . ' LIKE ' . $q->literal_like($tbl);
   PTDEBUG && _d($sql);
   my $row;
   eval {
      $row = $dbh->selectrow_arrayref($sql);
   };
   if ( $EVAL_ERROR ) {
      PTDEBUG && _d($EVAL_ERROR);
      return 0;
   }
   if ( !$row->[0] || $row->[0] ne $tbl ) {
      PTDEBUG && _d('Table does not exist');
      return 0;
   }

PTDEBUG && _d('Table', $db, $tbl, 'exists');
   return 1;

}

sub get_engine {
   my ( $self, $ddl, $opts ) = @_;
   my ( $engine ) = $ddl =~ m/\).*?(?:ENGINE|TYPE)=(\w+)/;
   PTDEBUG && _d('Storage engine:', $engine);
   return $engine || undef;
}

sub get_keys {
   my ( $self, $ddl, $opts, $is_nullable ) = @_;
   my $engine        = $self->get_engine($ddl);
   my $keys          = {};
   my $clustered_key = undef;

KEY:
   foreach my $key ( $ddl =~ m/^  ((?:[A-Z]+ )?KEY .*)$/gm ) {

next KEY if $key =~ m/FOREIGN/;

my $key_ddl = $key;
      PTDEBUG && _d('Parsed key:', $key_ddl);

if ( !$engine || $engine !~ m/MEMORY|HEAP/ ) {
         $key =~ s/USING HASH/USING BTREE/;
      }

my ( $type, $cols ) = $key =~ m/(?:USING (\w+))? $(.+)$/;
      my ( $special ) = $key =~ m/(FULLTEXT|SPATIAL)/;
      $type = $type || $special || 'BTREE';
      my ($name) = $key =~ m/(PRIMARY|`[^`]*`)/;
      my $unique = $key =~ m/PRIMARY|UNIQUE/ ? 1 : 0;
      my @cols;
      my @col_prefixes;
      foreach my $col_def ( $cols =~ m/`[^`]+`(?:$\d+$)?/g ) {
         my ($name, $prefix) = $col_def =~ m/`([^`]+)`(?:$(\d+)$)?/;
         push @cols, $name;
         push @col_prefixes, $prefix;
      }
      $name =~ s/`//g;

PTDEBUG && _d( $name, 'key cols:', join(', ', map { "`$_`" } @cols));

$keys->{$name} = {
         name         => $name,
         type         => $type,
         colnames     => $cols,
         cols         => \@cols,
         col_prefixes => \@col_prefixes,
         is_unique    => $unique,
         is_nullable  => scalar(grep { $is_nullable->{$_} } @cols),
         is_col       => { map { $_ => 1 } @cols },
         ddl          => $key_ddl,
      };

if ( ($engine || '') =~ m/InnoDB/i && !$clustered_key ) {
         my $this_key = $keys->{$name};
         if ( $this_key->{name} eq 'PRIMARY' ) {
            $clustered_key = 'PRIMARY';
         }
         elsif ( $this_key->{is_unique} && !$this_key->{is_nullable} ) {
            $clustered_key = $this_key->{name};
         }
         PTDEBUG && $clustered_key && _d('This key is the clustered key');
      }
   }

return $keys, $clustered_key;
}

sub get_fks {
   my ( $self, $ddl, $opts ) = @_;
   my $q   = $self->{Quoter};
   my $fks = {};

foreach my $fk (
      $ddl =~ m/CONSTRAINT .* FOREIGN KEY .* REFERENCES [^\)]*\)/mg )
   {
      my ( $name ) = $fk =~ m/CONSTRAINT `(.*?)`/;
      my ( $cols ) = $fk =~ m/FOREIGN KEY $([^$]+)\)/;
      my ( $parent, $parent_cols ) = $fk =~ m/REFERENCES (\S+) $([^$]+)\)/;

my ($db, $tbl) = $q->split_unquote($parent, $opts->{database});
      my %parent_tbl = (tbl => $tbl);
      $parent_tbl{db} = $db if $db;

if ( $parent !~ m/\./ && $opts->{database} ) {
         $parent = $q->quote($opts->{database}) . ".$parent";
      }

$fks->{$name} = {
         name           => $name,
         colnames       => $cols,
         cols           => [ map { s/[ `]+//g; $_; } split(',', $cols) ],
         parent_tbl     => \%parent_tbl,
         parent_tblname => $parent,
         parent_cols    => [ map { s/[ `]+//g; $_; } split(',', $parent_cols) ],
         parent_colnames=> $parent_cols,
         ddl            => $fk,
      };
   }

return $fks;
}

sub remove_auto_increment {
   my ( $self, $ddl ) = @_;
   $ddl =~ s/(^\).*?) AUTO_INCREMENT=\d+\b/$1/m;
   return $ddl;
}

sub get_table_status {
   my ( $self, $dbh, $db, $like ) = @_;
   my $q = $self->{Quoter};
   my $sql = "SHOW TABLE STATUS FROM " . $q->quote($db);
   my @params;
   if ( $like ) {
      $sql .= ' LIKE ?';
      push @params, $like;
   }
   PTDEBUG && _d($sql, @params);
   my $sth = $dbh->prepare($sql);
   eval { $sth->execute(@params); };
   if ($EVAL_ERROR) {
      PTDEBUG && _d($EVAL_ERROR);
      return;
   }
   my @tables = @{$sth->fetchall_arrayref({})};
   @tables = map {
      my %tbl; # Make a copy with lowercased keys
      @tbl{ map { lc $_ } keys %$_ } = values %$_;
      $tbl{engine} ||= $tbl{type} || $tbl{comment};
      delete $tbl{type};
      \%tbl;
   } @tables;
   return @tables;
}

my $ansi_quote_re = qr/" [^"]* (?: "" [^"]* )* (?<=.) "/ismx;
sub ansi_to_legacy {
   my ($self, $ddl) = @_;
   $ddl =~ s/($ansi_quote_re)/ansi_quote_replace($1)/ge;
   return $ddl;
}

sub ansi_quote_replace {
   my ($val) = @_;
   $val =~ s/^"|"$//g;
   $val =~ s/`/``/g;
   $val =~ s/""/"/g;
   return "`$val`";
}

1;
}
# ###########################################################################
# End TableParser package
# ###########################################################################

# ###########################################################################
# Transformers package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/Transformers.pm
#   t/lib/Transformers.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package Transformers;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Time::Local qw(timegm timelocal);
use Digest::MD5 qw(md5_hex);
use B qw();

BEGIN {
   require Exporter;
   our @ISA         = qw(Exporter);
   our %EXPORT_TAGS = ();
   our @EXPORT      = ();
   our @EXPORT_OK   = qw(
      micro_t
      percentage_of
      secs_to_time
      time_to_secs
      shorten
      ts
      parse_timestamp
      unix_timestamp
      any_unix_timestamp
      make_checksum
      crc32
      encode_json
   );
}

our $mysql_ts  = qr/(\d\d)(\d\d)(\d\d) +(\d+):(\d+):(\d+)(\.\d+)?/;
our $proper_ts = qr/(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d):(\d\d)(\.\d+)?/;
our $n_ts      = qr/(\d{1,5})([shmd]?)/; # Limit \d{1,5} because \d{6} looks

sub micro_t {
   my ( $t, %args ) = @_;
   my $p_ms = defined $args{p_ms} ? $args{p_ms} : 0;  # precision for ms vals
   my $p_s  = defined $args{p_s}  ? $args{p_s}  : 0;  # precision for s vals
   my $f;

$t = 0 if $t < 0;

$t = sprintf('%.17f', $t) if $t =~ /e/;

$t =~ s/\.(\d{1,6})\d*/\.$1/;

if ($t > 0 && $t <= 0.000999) {
      $f = ($t * 1000000) . 'us';
   }
   elsif ($t >= 0.001000 && $t <= 0.999999) {
      $f = sprintf("%.${p_ms}f", $t * 1000);
      $f = ($f * 1) . 'ms'; # * 1 to remove insignificant zeros
   }
   elsif ($t >= 1) {
      $f = sprintf("%.${p_s}f", $t);
      $f = ($f * 1) . 's'; # * 1 to remove insignificant zeros
   }
   else {
      $f = 0;  # $t should = 0 at this point
   }

return $f;
}

sub percentage_of {
   my ( $is, $of, %args ) = @_;
   my $p   = $args{p} || 0; # float precision
   my $fmt = $p ? "%.${p}f" : "%d";
   return sprintf $fmt, ($is * 100) / ($of ||= 1);
}

sub secs_to_time {
   my ( $secs, $fmt ) = @_;
   $secs ||= 0;
   return '00:00' unless $secs;

$fmt ||= $secs >= 86_400 ? 'd'
          : $secs >= 3_600  ? 'h'
          :                   'm';

return
      $fmt eq 'd' ? sprintf(
         "%d+%02d:%02d:%02d",
         int($secs / 86_400),
         int(($secs % 86_400) / 3_600),
         int(($secs % 3_600) / 60),
         $secs % 60)
      : $fmt eq 'h' ? sprintf(
         "%02d:%02d:%02d",
         int(($secs % 86_400) / 3_600),
         int(($secs % 3_600) / 60),
         $secs % 60)
      : sprintf(
         "%02d:%02d",
         int(($secs % 3_600) / 60),
         $secs % 60);
}

sub time_to_secs {
   my ( $val, $default_suffix ) = @_;
   die "I need a val argument" unless defined $val;
   my $t = 0;
   my ( $prefix, $num, $suffix ) = $val =~ m/([+-]?)(\d+)([a-z])?$/;
   $suffix = $suffix || $default_suffix || 's';
   if ( $suffix =~ m/[smhd]/ ) {
      $t = $suffix eq 's' ? $num * 1        # Seconds
         : $suffix eq 'm' ? $num * 60       # Minutes
         : $suffix eq 'h' ? $num * 3600     # Hours
         :                  $num * 86400;   # Days

$t *= -1 if $prefix && $prefix eq '-';
   }
   else {
      die "Invalid suffix for $val: $suffix";
   }
   return $t;
}

sub shorten {
   my ( $num, %args ) = @_;
   my $p = defined $args{p} ? $args{p} : 2;     # float precision
   my $d = defined $args{d} ? $args{d} : 1_024; # divisor
   my $n = 0;
   my @units = ('', qw(k M G T P E Z Y));
   while ( $num >= $d && $n < @units - 1 ) {
      $num /= $d;
      ++$n;
   }
   return sprintf(
      $num =~ m/\./ || $n
         ? "%.${p}f%s"
         : '%d',
      $num, $units[$n]);
}

sub ts {
   my ( $time, $gmt ) = @_;
   my ( $sec, $min, $hour, $mday, $mon, $year )
      = $gmt ? gmtime($time) : localtime($time);
   $mon  += 1;
   $year += 1900;
   my $val = sprintf("%d-%02d-%02dT%02d:%02d:%02d",
      $year, $mon, $mday, $hour, $min, $sec);
   if ( my ($us) = $time =~ m/(\.\d+)$/ ) {
      $us = sprintf("%.6f", $us);
      $us =~ s/^0\././;
      $val .= $us;
   }
   return $val;
}

sub parse_timestamp {
   my ( $val ) = @_;
   if ( my($y, $m, $d, $h, $i, $s, $f)
         = $val =~ m/^$mysql_ts$/ )
   {
      return sprintf "%d-%02d-%02d %02d:%02d:"
                     . (defined $f ? '%09.6f' : '%02d'),
                     $y + 2000, $m, $d, $h, $i, (defined $f ? $s + $f : $s);
   }
   elsif ( $val =~ m/^$proper_ts$/ ) {
      return $val;
   }
   return $val;
}

sub unix_timestamp {
   my ( $val, $gmt ) = @_;
   if ( my($y, $m, $d, $h, $i, $s, $us) = $val =~ m/^$proper_ts$/ ) {
      $val = $gmt
         ? timegm($s, $i, $h, $d, $m - 1, $y)
         : timelocal($s, $i, $h, $d, $m - 1, $y);
      if ( defined $us ) {
         $us = sprintf('%.6f', $us);
         $us =~ s/^0\././;
         $val .= $us;
      }
   }
   return $val;
}

sub any_unix_timestamp {
   my ( $val, $callback ) = @_;

if ( my ($n, $suffix) = $val =~ m/^$n_ts$/ ) {
      $n = $suffix eq 's' ? $n            # Seconds
         : $suffix eq 'm' ? $n * 60       # Minutes
         : $suffix eq 'h' ? $n * 3600     # Hours
         : $suffix eq 'd' ? $n * 86400    # Days
         :                  $n;           # default: Seconds
      PTDEBUG && _d('ts is now - N[shmd]:', $n);
      return time - $n;
   }
   elsif ( $val =~ m/^\d{9,}/ ) {
      PTDEBUG && _d('ts is already a unix timestamp');
      return $val;
   }
   elsif ( my ($ymd, $hms) = $val =~ m/^(\d{6})(?:\s+(\d+:\d+:\d+))?/ ) {
      PTDEBUG && _d('ts is MySQL slow log timestamp');
      $val .= ' 00:00:00' unless $hms;
      return unix_timestamp(parse_timestamp($val));
   }
   elsif ( ($ymd, $hms) = $val =~ m/^(\d{4}-\d\d-\d\d)(?:[T ](\d+:\d+:\d+))?/) {
      PTDEBUG && _d('ts is properly formatted timestamp');
      $val .= ' 00:00:00' unless $hms;
      return unix_timestamp($val);
   }
   else {
      PTDEBUG && _d('ts is MySQL expression');
      return $callback->($val) if $callback && ref $callback eq 'CODE';
   }

PTDEBUG && _d('Unknown ts type:', $val);
   return;
}

sub make_checksum {
   my ( $val ) = @_;
   my $checksum = uc substr(md5_hex($val), -16);
   PTDEBUG && _d($checksum, 'checksum for', $val);
   return $checksum;
}

sub crc32 {
   my ( $string ) = @_;
   return unless $string;
   my $poly = 0xEDB88320;
   my $crc  = 0xFFFFFFFF;
   foreach my $char ( split(//, $string) ) {
      my $comp = ($crc ^ ord($char)) & 0xFF;
      for ( 1 .. 8 ) {
         $comp = $comp & 1 ? $poly ^ ($comp >> 1) : $comp >> 1;
      }
      $crc = (($crc >> 8) & 0x00FFFFFF) ^ $comp;
   }
   return $crc ^ 0xFFFFFFFF;
}

my $got_json = eval { require JSON };
sub encode_json {
   return JSON::encode_json(@_) if $got_json;
   my ( $data ) = @_;
   return (object_to_json($data) || '');
}

sub object_to_json {
   my ($obj) = @_;
   my $type  = ref($obj);

if($type eq 'HASH'){
      return hash_to_json($obj);
   }
   elsif($type eq 'ARRAY'){
      return array_to_json($obj);
   }
   else {
      return value_to_json($obj);
   }
}

sub hash_to_json {
   my ($obj) = @_;
   my @res;
   for my $k ( sort { $a cmp $b } keys %$obj ) {
      push @res, string_to_json( $k )
         .  ":"
         . ( object_to_json( $obj->{$k} ) || value_to_json( $obj->{$k} ) );
   }
   return '{' . ( @res ? join( ",", @res ) : '' )  . '}';
}

sub array_to_json {
   my ($obj) = @_;
   my @res;

for my $v (@$obj) {
      push @res, object_to_json($v) || value_to_json($v);
   }

return '[' . ( @res ? join( ",", @res ) : '' ) . ']';
}

sub value_to_json {
   my ($value) = @_;

return 'null' if(!defined $value);

my $b_obj = B::svref_2object(\$value);  # for round trip problem
   my $flags = $b_obj->FLAGS;
   return $value # as is 
      if $flags & ( B::SVp_IOK | B::SVp_NOK ) and !( $flags & B::SVp_POK ); # SvTYPE is IV or NV?

my $type = ref($value);

if( !$type ) {
      return string_to_json($value);
   }
   else {
      return 'null';
   }

}

my %esc = (
   "\n" => '\n',
   "\r" => '\r',
   "\t" => '\t',
   "\f" => '\f',
   "\b" => '\b',
   "\"" => '\"',
   "\\" => '\\\\',
   "\'" => '\\\'',
);

sub string_to_json {
   my ($arg) = @_;

$arg =~ s/([\x22\x5c\n\r\t\f\b])/$esc{$1}/g;
   $arg =~ s/\//\\\//g;
   $arg =~ s/([\x00-\x08\x0b\x0e-\x1f])/'\\u00' . unpack('H2', $1)/eg;

utf8::upgrade($arg);
   utf8::encode($arg);

return '"' . $arg . '"';
}

1;
}
# ###########################################################################
# End Transformers package
# ###########################################################################

# ###########################################################################
# Schema package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/Schema.pm
#   t/lib/Schema.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package Schema;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

sub new {
   my ( $class, %args ) = @_;
   my @required_args = qw();
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }

my $self = {
      %args,
      schema  => {},  # keyed on db->tbl
   };
   return bless $self, $class;
}

sub get_schema {
   my ( $self ) = @_;
   return $self->{schema};
}

sub get_table {
   my ( $self, $db_name, $tbl_name ) = @_;
   if ( exists $self->{schema}->{$db_name}
        && exists $self->{schema}->{$db_name}->{$tbl_name} ) {
      return $self->{schema}->{$db_name}->{$tbl_name};
   }
   return;
}

sub add_schema_object {
   my ( $self, $schema_object ) = @_;
   die "I need a schema_object argument" unless $schema_object;

my ($db, $tbl) = @{$schema_object}{qw(db tbl)};
   if ( !$db || !$tbl ) {
      warn "No database or table for schema object";
      return;
   }

my $tbl_struct = $schema_object->{tbl_struct};
   if ( !$tbl_struct ) {
      warn "No table structure for $db.$tbl";
      return;
   }

$self->{schema}->{lc $db}->{lc $tbl} = $schema_object;

return;
}

sub find_column {
   my ( $self, %args ) = @_;
   my $ignore = $args{ignore};
   my $schema = $self->{schema};

my ($col, $tbl, $db);
   if ( my $col_name = $args{col_name} ) {
      ($col, $tbl, $db) = reverse map { s/`//g; $_ } split /[.]/, $col_name;
      PTDEBUG && _d('Column', $col_name, 'has db', $db, 'tbl', $tbl,
         'col', $col);
   }
   else {
      ($col, $tbl, $db) = @args{qw(col tbl db)};
   }

$db  = lc($db  || '');
   $tbl = lc($tbl || '');
   $col = lc($col || '');

if ( !$col ) {
      PTDEBUG && _d('No column specified or parsed');
      return;
   }
   PTDEBUG && _d('Finding column', $col, 'in', $db, $tbl);

if ( $db && !$schema->{$db} ) {
      PTDEBUG && _d('Database', $db, 'does not exist');
      return;
   }

if ( $db && $tbl && !$schema->{$db}->{$tbl} ) {
      PTDEBUG && _d('Table', $tbl, 'does not exist in database', $db);
      return;
   }

my @tbls;
   my @search_dbs = $db ? ($db) : keys %$schema;
   DATABASE:
   foreach my $search_db ( @search_dbs ) {
      my @search_tbls = $tbl ? ($tbl) : keys %{$schema->{$search_db}};

TABLE:
      foreach my $search_tbl ( @search_tbls ) {
         next DATABASE unless exists $schema->{$search_db}->{$search_tbl};

if ( $ignore
              && grep { $_->{db} eq $search_db && $_->{tbl} eq $search_tbl }
                 @$ignore ) {
            PTDEBUG && _d('Ignoring', $search_db, $search_tbl, $col);
            next TABLE;
         }

my $tbl = $schema->{$search_db}->{$search_tbl};
         if ( $tbl->{tbl_struct}->{is_col}->{$col} ) {
            PTDEBUG && _d('Column', $col, 'exists in', $tbl->{db}, $tbl->{tbl});
            push @tbls, $tbl;
         }
      }
   }

return \@tbls;
}

sub find_table {
   my ( $self, %args ) = @_;
   my $ignore = $args{ignore};
   my $schema = $self->{schema};

my ($tbl, $db);
   if ( my $tbl_name = $args{tbl_name} ) {
      ($tbl, $db) = reverse map { s/`//g; $_ } split /[.]/, $tbl_name;
      PTDEBUG && _d('Table', $tbl_name, 'has db', $db, 'tbl', $tbl);
   }
   else {
      ($tbl, $db) = @args{qw(tbl db)};
   }

$db  = lc($db  || '');
   $tbl = lc($tbl || '');

if ( !$tbl ) {
      PTDEBUG && _d('No table specified or parsed');
      return;
   }
   PTDEBUG && _d('Finding table', $tbl, 'in', $db);

if ( $db && !$schema->{$db} ) {
      PTDEBUG && _d('Database', $db, 'does not exist');
      return;
   }

if ( $db && $tbl && !$schema->{$db}->{$tbl} ) {
      PTDEBUG && _d('Table', $tbl, 'does not exist in database', $db);
      return;
   }

my @dbs;
   my @search_dbs = $db ? ($db) : keys %$schema;
   DATABASE:
   foreach my $search_db ( @search_dbs ) {
      if ( $ignore && grep { $_->{db} eq $search_db } @$ignore ) {
         PTDEBUG && _d('Ignoring', $search_db);
         next DATABASE;
      }

if ( exists $schema->{$search_db}->{$tbl} ) {
         PTDEBUG && _d('Table', $tbl, 'exists in', $search_db);
         push @dbs, $search_db;
      }
   }

return \@dbs;
}

1;
}
# ###########################################################################
# End Schema package
# ###########################################################################

# ###########################################################################
# SchemaIterator package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/SchemaIterator.pm
#   t/lib/SchemaIterator.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package SchemaIterator;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
$Data::Dumper::Indent    = 1;
$Data::Dumper::Sortkeys  = 1;
$Data::Dumper::Quotekeys = 0;

my $open_comment = qr{/\*!\d{5} };
my $tbl_name     = qr{
   CREATE\s+
   (?:TEMPORARY\s+)?
   TABLE\s+
   (?:IF NOT EXISTS\s+)?
   ([^\(]+)
}x;

sub new {
   my ( $class, %args ) = @_;
   my @required_args = qw(OptionParser TableParser Quoter);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }

my ($file_itr, $dbh) = @args{qw(file_itr dbh)};
   die "I need either a dbh or file_itr argument"
      if (!$dbh && !$file_itr) || ($dbh && $file_itr);

my %resume;
   if ( my $table = $args{resume} ) {
      PTDEBUG && _d('Will resume from or after', $table);
      my ($db, $tbl) = $args{Quoter}->split_unquote($table);
      die "Resume table must be database-qualified: $table"
         unless $db && $tbl;
      $resume{db}  = $db;
      $resume{tbl} = $tbl;
   }

my $self = {
      %args,
      resume  => \%resume,
      filters => _make_filters(%args),
   };

return bless $self, $class;
}

sub _make_filters {
   my ( %args ) = @_;
   my @required_args = qw(OptionParser Quoter);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }
   my ($o, $q) = @args{@required_args};

my %filters;

my @simple_filters = qw(
      databases         tables         engines
      ignore-databases  ignore-tables  ignore-engines);
   FILTER:
   foreach my $filter ( @simple_filters ) {
      if ( $o->has($filter) ) {
         my $objs = $o->get($filter);
         next FILTER unless $objs && scalar keys %$objs;
         my $is_table = $filter =~ m/table/ ? 1 : 0;
         foreach my $obj ( keys %$objs ) {
            die "Undefined value for --$filter" unless $obj;
            $obj = lc $obj;
            if ( $is_table ) {
               my ($db, $tbl) = $q->split_unquote($obj);
               $db ||= '*';
               PTDEBUG && _d('Filter', $filter, 'value:', $db, $tbl);
               $filters{$filter}->{$db}->{$tbl} = 1;
            }
            else { # database
               PTDEBUG && _d('Filter', $filter, 'value:', $obj);
               $filters{$filter}->{$obj} = 1;
            }
         }
      }
   }

my @regex_filters = qw(
      databases-regex         tables-regex
      ignore-databases-regex  ignore-tables-regex);
   REGEX_FILTER:
   foreach my $filter ( @regex_filters ) {
      if ( $o->has($filter) ) {
         my $pat = $o->get($filter);
         next REGEX_FILTER unless $pat;
         $filters{$filter} = qr/$pat/;
         PTDEBUG && _d('Filter', $filter, 'value:', $filters{$filter});
      }
   }

PTDEBUG && _d('Schema object filters:', Dumper(\%filters));
   return \%filters;
}

sub next {
   my ( $self ) = @_;

if ( !$self->{initialized} ) {
      $self->{initialized} = 1;
      if ( $self->{resume}->{tbl} ) {
         if ( !$self->table_is_allowed(@{$self->{resume}}{qw(db tbl)}) ) {
            PTDEBUG && _d('Will resume after',
               join('.', @{$self->{resume}}{qw(db tbl)}));
            $self->{resume}->{after}->{tbl} = 1;
         }
         if ( !$self->database_is_allowed($self->{resume}->{db}) ) {
            PTDEBUG && _d('Will resume after', $self->{resume}->{db});
            $self->{resume}->{after}->{db}  = 1;
         }
      }
   }

my $schema_obj;
   if ( $self->{file_itr} ) {
      $schema_obj= $self->_iterate_files();
   }
   else { # dbh
      $schema_obj= $self->_iterate_dbh();
   }

if ( $schema_obj ) {
      if ( my $schema = $self->{Schema} ) {
         $schema->add_schema_object($schema_obj);
      }
      PTDEBUG && _d('Next schema object:',
         $schema_obj->{db}, $schema_obj->{tbl});
   }

return $schema_obj;
}

sub _iterate_files {
   my ( $self ) = @_;

if ( !$self->{fh} ) {
      my ($fh, $file) = $self->{file_itr}->();
      if ( !$fh ) {
         PTDEBUG && _d('No more files to iterate');
         return;
      }
      $self->{fh}   = $fh;
      $self->{file} = $file;
   }
   my $fh = $self->{fh};
   PTDEBUG && _d('Getting next schema object from', $self->{file});

local $INPUT_RECORD_SEPARATOR = '';
   CHUNK:
   while (defined(my $chunk = <$fh>)) {
      if ($chunk =~ m/Database: (\S+)/) {
         my $db = $1; # XXX
         $db =~ s/^`//;  # strip leading `
         $db =~ s/`$//;  # and trailing `
         if ( $self->database_is_allowed($db)
              && $self->_resume_from_database($db) ) {
            $self->{db} = $db;
         }
      }
      elsif ($self->{db} && $chunk =~ m/CREATE TABLE/) {
         if ($chunk =~ m/DROP VIEW IF EXISTS/) {
            PTDEBUG && _d('Table is a VIEW, skipping');
            next CHUNK;
         }

my ($tbl) = $chunk =~ m/$tbl_name/;
         $tbl      =~ s/^\s*`//;
         $tbl      =~ s/`\s*$//;
         if ( $self->_resume_from_table($tbl)
              && $self->table_is_allowed($self->{db}, $tbl) ) {
            my ($ddl) = $chunk =~ m/^(?:$open_comment)?(CREATE TABLE.+?;)$/ms;
            if ( !$ddl ) {
               warn "Failed to parse CREATE TABLE from\n" . $chunk;
               next CHUNK;
            }
            $ddl =~ s/ \*\/;\Z/;/;  # remove end of version comment
            my $tbl_struct = $self->{TableParser}->parse($ddl);
            if ( $self->engine_is_allowed($tbl_struct->{engine}) ) {
               return {
                  db         => $self->{db},
                  tbl        => $tbl,
                  name       => $self->{Quoter}->quote($self->{db}, $tbl),
                  ddl        => $ddl,
                  tbl_struct => $tbl_struct,
               };
            }
         }
      }
   }  # CHUNK

PTDEBUG && _d('No more schema objects in', $self->{file});
   close $self->{fh};
   $self->{fh} = undef;

return $self->_iterate_files();
}

sub _iterate_dbh {
   my ( $self ) = @_;
   my $q   = $self->{Quoter};
   my $tp  = $self->{TableParser};
   my $dbh = $self->{dbh};
   PTDEBUG && _d('Getting next schema object from dbh', $dbh);

if ( !defined $self->{dbs} ) {
      my $sql = 'SHOW DATABASES';
      PTDEBUG && _d($sql);
      my @dbs = grep {
                  $self->_resume_from_database($_)
                  &&
                  $self->database_is_allowed($_)
                } @{$dbh->selectcol_arrayref($sql)};
      PTDEBUG && _d('Found', scalar @dbs, 'databases');
      $self->{dbs} = \@dbs;
   }

DATABASE:
   while ( $self->{db} || defined(my $db = shift @{$self->{dbs}}) ) {
      if ( !$self->{db} ) {
         PTDEBUG && _d('Next database:', $db);
         $self->{db} = $db;
      }

if ( !$self->{tbls} ) {
         my $sql = 'SHOW /*!50002 FULL*/ TABLES FROM ' . $q->quote($self->{db});
         PTDEBUG && _d($sql);
         my @tbls = map {
            $_->[0];  # (tbl, type)
         }
         grep {
            my ($tbl, $type) = @$_;
            (!$type || ($type ne 'VIEW'))
            && $self->_resume_from_table($tbl)
            && $self->table_is_allowed($self->{db}, $tbl);
         }
         @{$dbh->selectall_arrayref($sql)};
         PTDEBUG && _d('Found', scalar @tbls, 'tables in database',$self->{db});
         $self->{tbls} = \@tbls;
      }

TABLE:
      while ( my $tbl = shift @{$self->{tbls}} ) {
         my $ddl = eval { $tp->get_create_table($dbh, $self->{db}, $tbl) };
         if ( my $e = $EVAL_ERROR ) {
            my $table_name = "$self->{db}.$tbl";
            if ( $e =~ /\QTable '$table_name' doesn't exist/ ) {
               PTDEBUG && _d("$table_name no longer exists");
            }
            else {
               warn "Skipping $table_name because SHOW CREATE TABLE failed: $e";
            }
            next TABLE;
         }

my $tbl_struct = $tp->parse($ddl);
         if ( $self->engine_is_allowed($tbl_struct->{engine}) ) {
            return {
               db         => $self->{db},
               tbl        => $tbl,
               name       => $q->quote($self->{db}, $tbl),
               ddl        => $ddl,
               tbl_struct => $tbl_struct,
            };
         }
      }

PTDEBUG && _d('No more tables in database', $self->{db});
      $self->{db}   = undef;
      $self->{tbls} = undef;
   } # DATABASE

PTDEBUG && _d('No more databases');
   return;
}

sub database_is_allowed {
   my ( $self, $db ) = @_;
   die "I need a db argument" unless $db;

$db = lc $db;

my $filter = $self->{filters};

if ( $db =~ m/information_schema|performance_schema|lost\+found/ ) {
      PTDEBUG && _d('Database', $db, 'is a system database, ignoring');
      return 0;
   }

if ( $self->{filters}->{'ignore-databases'}->{$db} ) {
      PTDEBUG && _d('Database', $db, 'is in --ignore-databases list');
      return 0;
   }

if ( $filter->{'ignore-databases-regex'}
        && $db =~ $filter->{'ignore-databases-regex'} ) {
      PTDEBUG && _d('Database', $db, 'matches --ignore-databases-regex');
      return 0;
   }

if ( $filter->{'databases'}
        && !$filter->{'databases'}->{$db} ) {
      PTDEBUG && _d('Database', $db, 'is not in --databases list, ignoring');
      return 0;
   }

if ( $filter->{'databases-regex'}
        && $db !~ $filter->{'databases-regex'} ) {
      PTDEBUG && _d('Database', $db, 'does not match --databases-regex, ignoring');
      return 0;
   }

return 1;
}

sub table_is_allowed {
   my ( $self, $db, $tbl ) = @_;
   die "I need a db argument"  unless $db;
   die "I need a tbl argument" unless $tbl;

$db  = lc $db;
   $tbl = lc $tbl;

my $filter = $self->{filters};

if ( $filter->{'ignore-tables'}->{'*'}->{$tbl} 
         || $filter->{'ignore-tables'}->{$db}->{$tbl}) {
      PTDEBUG && _d('Table', $tbl, 'is in --ignore-tables list');
      return 0;
   }

if ( $filter->{'ignore-tables-regex'}
        && $tbl =~ $filter->{'ignore-tables-regex'} ) {
      PTDEBUG && _d('Table', $tbl, 'matches --ignore-tables-regex');
      return 0;
   }

if ( $filter->{'tables'}
        && (!$filter->{'tables'}->{'*'}->{$tbl} && !$filter->{'tables'}->{$db}->{$tbl}) ) { 
      PTDEBUG && _d('Table', $tbl, 'is not in --tables list, ignoring');
      return 0;
   }

if ( $filter->{'tables-regex'}
        && $tbl !~ $filter->{'tables-regex'} ) {
      PTDEBUG && _d('Table', $tbl, 'does not match --tables-regex, ignoring');
      return 0;
   }

if ( $filter->{'tables'}
        && $filter->{'tables'}->{$tbl}
        && $filter->{'tables'}->{$tbl} ne '*'
        && $filter->{'tables'}->{$tbl} ne $db ) {
      PTDEBUG && _d('Table', $tbl, 'is only allowed in database',
         $filter->{'tables'}->{$tbl});
      return 0;
   }

return 1;
}

sub engine_is_allowed {
   my ( $self, $engine ) = @_;

if ( !$engine ) {
      PTDEBUG && _d('No engine specified; allowing the table');
      return 1;
   }

$engine = lc $engine;

my $filter = $self->{filters};

if ( $filter->{'ignore-engines'}->{$engine} ) {
      PTDEBUG && _d('Engine', $engine, 'is in --ignore-databases list');
      return 0;
   }

if ( $filter->{'engines'}
        && !$filter->{'engines'}->{$engine} ) {
      PTDEBUG && _d('Engine', $engine, 'is not in --engines list, ignoring');
      return 0;
   }

return 1;
}

sub _resume_from_database {
   my ($self, $db) = @_;

return 1 unless $self->{resume}->{db};
   if ( $db eq $self->{resume}->{db} ) {
      if ( !$self->{resume}->{after}->{db} ) {
         PTDEBUG && _d('Resuming from db', $db);
         delete $self->{resume}->{db};
         return 1;
      }
      else {
         PTDEBUG && _d('Resuming after db', $db);
         delete $self->{resume}->{db};
         delete $self->{resume}->{tbl};
      }
   }

return 0;
}

sub _resume_from_table {
   my ($self, $tbl) = @_;

return 1 unless $self->{resume}->{tbl};

if ( $tbl eq $self->{resume}->{tbl} ) {
      if ( !$self->{resume}->{after}->{tbl} ) {
         PTDEBUG && _d('Resuming from table', $tbl);
         delete $self->{resume}->{tbl};
         return 1;
      }
      else {
         PTDEBUG && _d('Resuming after table', $tbl);
         delete $self->{resume}->{tbl};
      }
   }

return 0;
}

1;
}
# ###########################################################################
# End SchemaIterator package
# ###########################################################################

# ###########################################################################
# FileIterator package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/FileIterator.pm
#   t/lib/FileIterator.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package FileIterator;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

sub new {
   my ( $class, %args ) = @_;
   my $self = {
      %args,
   };
   return bless $self, $class;
}

sub get_file_itr {
   my ( $self, @filenames ) = @_;

my @final_filenames;
   FILENAME:
   foreach my $fn ( @filenames ) {
      if ( !defined $fn ) {
         warn "Skipping undefined filename";
         next FILENAME;
      }
      if ( $fn ne '-' ) {
         if ( !-e $fn || !-r $fn ) {
            warn "$fn does not exist or is not readable";
            next FILENAME;
         }
      }
      push @final_filenames, $fn;
   }

if ( !@filenames ) {
      push @final_filenames, '-';
      PTDEBUG && _d('Auto-adding "-" to the list of filenames');
   }

PTDEBUG && _d('Final filenames:', @final_filenames);
   return sub {
      while ( @final_filenames ) {
         my $fn = shift @final_filenames;
         PTDEBUG && _d('Filename:', $fn);
         if ( $fn eq '-' ) { # Magical STDIN filename.
            return (*STDIN, undef, undef);
         }
         open my $fh, '<', $fn or warn "Cannot open $fn: $OS_ERROR";
         if ( $fh ) {
            return ( $fh, $fn, -s $fn );
         }
      }
      return (); # Avoids $f being set to 0 in list context.
   };
}

1;
}
# ###########################################################################
# End FileIterator package
# ###########################################################################

# ###########################################################################
# ExplainAnalyzer package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/ExplainAnalyzer.pm
#   t/lib/ExplainAnalyzer.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package ExplainAnalyzer;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
$Data::Dumper::Indent    = 1;
$Data::Dumper::Sortkeys  = 1;
$Data::Dumper::Quotekeys = 0;

sub new {
   my ( $class, %args ) = @_;
   foreach my $arg ( qw(QueryRewriter QueryParser) ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my $self = {
      %args,
   };
   return bless $self, $class;
}

sub explain_query {
   my ( $self, %args ) = @_;
   foreach my $arg ( qw(dbh query) ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my ($query, $dbh) = @args{qw(query dbh)};
   $query = $self->{QueryRewriter}->convert_to_select($query);
   if ( $query !~ m/^\s*select/i ) {
      PTDEBUG && _d("Cannot EXPLAIN non-SELECT query:",
         (length $query <= 100 ? $query : substr($query, 0, 100) . "..."));
      return;
   }
   my $sql = "EXPLAIN $query";
   PTDEBUG && _d($dbh, $sql);
   my $explain = $dbh->selectall_arrayref($sql, { Slice => {} });
   PTDEBUG && _d("Result of EXPLAIN:", Dumper($explain));
   return $explain;
}

sub normalize {
   my ( $self, $explain ) = @_;
   my @result; # Don't modify the input.

foreach my $row ( @$explain ) {
      $row = { %$row }; # Make a copy -- don't modify the input.

foreach my $col ( qw(key possible_keys key_len ref) ) {
         $row->{$col} = [ split(/,/, $row->{$col} || '') ];
      }

$row->{Extra} = {
         map {
            my $var = $_;

if ( my ($key, $vals) = $var =~ m/(Using union)$([^)]+)$/ ) {
               $key => [ split(/,/, $vals) ];
            }

else {
               $var => 1;
            }
         }
         split(/; /, $row->{Extra} || '') # Split on semicolons.
      };

push @result, $row;
   }

return \@result;
}

sub get_alternate_indexes {
   my ( $self, $keys, $possible_keys ) = @_;
   my %used = map { $_ => 1 } @$keys;
   return [ grep { !$used{$_} } @$possible_keys ];
}

sub get_index_usage {
   my ( $self, %args ) = @_;
   foreach my $arg ( qw(query explain) ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my ($query, $explain) = @args{qw(query explain)};
   my @result;

my $lookup = $self->{QueryParser}->get_aliases($query);

foreach my $row ( @$explain ) {

next if !defined $row->{table}
         || $row->{table} =~ m/^<(derived|union)\d/;

my $table = $lookup->{TABLE}->{$row->{table}} || $row->{table};
      my $db    = $lookup->{DATABASE}->{$table}     || $args{db};
      push @result, {
         db  => $db,
         tbl => $table,
         idx => $row->{key},
         alt => $self->get_alternate_indexes(
                  $row->{key}, $row->{possible_keys}),
      };
   }

PTDEBUG && _d("Index usage for",
      (length $query <= 100 ? $query : substr($query, 0, 100) . "..."),
      ":", Dumper(\@result));
   return \@result;
}

sub get_usage_for {
   my ( $self, $checksum, $db ) = @_;
   die "I need a checksum and db" unless defined $checksum && defined $db;
   my $usage;
   if ( exists $self->{usage}->{$db} # Don't auto-vivify
     && exists $self->{usage}->{$db}->{$checksum} )
   {
      $usage = $self->{usage}->{$db}->{$checksum};
   }
   PTDEBUG && _d("Usage for",
      (length $checksum <= 100 ? $checksum : substr($checksum, 0, 100) . "..."),
      "on", $db, ":", Dumper($usage));
   return $usage;
}

sub save_usage_for {
   my ( $self, $checksum, $db, $usage ) = @_;
   die "I need a checksum and db" unless defined $checksum && defined $db;
   $self->{usage}->{$db}->{$checksum} = $usage;
}

sub fingerprint {
   my ( $self, %args ) = @_;
   my @required_args = qw(explain);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my ($explain) = @args{@required_args};
}

1;
}
# ###########################################################################
# End ExplainAnalyzer package
# ###########################################################################

# ###########################################################################
# IndexUsage package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/IndexUsage.pm
#   t/lib/IndexUsage.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package IndexUsage;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

sub new {
   my ( $class, %args ) = @_;
 
   my $self = {
      %args,
      tables_for      => {}, # Keyed off db
      indexes_for     => {}, # Keyed off db->tbl
      queries         => {}, # Keyed off query id
      index_usage     => {}, # Keyed off query id->db->tbl
      alt_index_usage => {}, # Keyed off query id->db->tbl->index
   };

return bless $self, $class;
}

sub add_indexes {
   my ( $self, %args ) = @_;
   my @required_args = qw(db tbl indexes);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }
   my ($db, $tbl, $indexes) = @args{@required_args};

$self->{tables_for}->{$db}->{$tbl}  = 0;  # usage cnt, zero until used
   $self->{indexes_for}->{$db}->{$tbl} = $indexes;
   foreach my $index ( keys %$indexes ) {
      $indexes->{$index}->{cnt} = 0;
   }

return;
}

sub add_query {
   my ( $self, %args ) = @_;
   my @required_args = qw(query_id fingerprint sample);
   foreach my $arg ( @required_args  ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my ($query_id, $fingerprint, $sample) = @args{@required_args};

$self->{queries}->{$query_id} = {
      fingerprint => $fingerprint,
      sample      => $sample,
   };

return;
}

sub add_table_usage {
   my ( $self, $db, $tbl ) = @_;
   die "I need a db and table" unless defined $db && defined $tbl;
   ++$self->{tables_for}->{$db}->{$tbl};
   return;
}

sub add_index_usage {
   my ( $self, %args ) = @_;
   my @required_args = qw(usage);
   foreach my $arg ( @required_args  ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my ($usage) = @args{@required_args};

foreach my $access ( @$usage ) {
      my ($db, $tbl, $idx, $alt) = @{$access}{qw(db tbl idx alt)};
      foreach my $index ( @$idx ) {
         $self->{indexes_for}->{$db}->{$tbl}->{$index}->{cnt}++;

if ( my $query_id = $args{query_id} ) {
            $self->{index_usage}->{$query_id}->{$db}->{$tbl}->{$index}++;
            foreach my $alt_index ( @$alt ) {
               $self->{alt_index_usage}->{$query_id}->{$db}->{$tbl}->{$index}->{$alt_index}++;
            }
         }

} # INDEX
   } # ACCESS

return;
}

sub find_unused_indexes {
   my ( $self, $callback ) = @_;
   die "I need a callback" unless $callback;
   PTDEBUG && _d("Finding unused indexes");

DATABASE:
   foreach my $db ( sort keys %{$self->{indexes_for}} ) {
      TABLE:
      foreach my $tbl ( sort keys %{$self->{indexes_for}->{$db}} ) {
         next TABLE unless $self->{tables_for}->{$db}->{$tbl}; # Skip unused
         my $indexes = $self->{indexes_for}->{$db}->{$tbl};
         my @unused_indexes;
         foreach my $index ( sort keys %$indexes ) {
            if ( !$indexes->{$index}->{cnt} ) { # count of times accessed/used
               push @unused_indexes, $indexes->{$index};
            }
         }

if ( @unused_indexes ) {
            $callback->(
               {  db  => $db,
                  tbl => $tbl,
                  idx => \@unused_indexes,
               }
            );
         }
      } # TABLE
   } # DATABASE

return;
}

sub save_results {
   my ( $self, %args ) = @_;
   my @required_args = qw(dbh db);
   foreach my $arg ( @required_args  ) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   my ($dbh, $db) = @args{@required_args};
   PTDEBUG && _d("Saving results to tables in database", $db);

PTDEBUG && _d("Saving index data");
   my $insert_index_sth = $dbh->prepare(
      "INSERT INTO `$db`.`indexes` (db, tbl, idx, cnt) VALUES (?, ?, ?, ?) "
      . "ON DUPLICATE KEY UPDATE cnt = cnt + ?");
   foreach my $db ( keys %{$self->{indexes_for}} ) {
      foreach my $tbl ( keys %{$self->{indexes_for}->{$db}} ) {
         foreach my $index ( keys %{$self->{indexes_for}->{$db}->{$tbl}} ) {
            my $cnt = $self->{indexes_for}->{$db}->{$tbl}->{$index}->{cnt};
            $insert_index_sth->execute($db, $tbl, $index, $cnt, $cnt);
         }
      }
   }

PTDEBUG && _d("Saving table data");
   my $insert_tbl_sth = $dbh->prepare(
      "INSERT INTO `$db`.`tables` (db, tbl, cnt) VALUES (?, ?, ?) "
      . "ON DUPLICATE KEY UPDATE cnt = cnt + ?");
   foreach my $db ( keys %{$self->{tables_for}} ) {
      foreach my $tbl ( keys %{$self->{tables_for}->{$db}} ) {
         my $cnt = $self->{tables_for}->{$db}->{$tbl};
         $insert_tbl_sth->execute($db, $tbl, $cnt, $cnt);
      }
   }

PTDEBUG && _d("Save query data");
   my $insert_query_sth = $dbh->prepare(
      "INSERT IGNORE INTO `$db`.`queries` (query_id, fingerprint, sample) "
      . " VALUES (CONV(?, 16, 10), ?, ?)");
   foreach my $query_id ( keys %{$self->{queries}} ) {
      my $query = $self->{queries}->{$query_id};
      $insert_query_sth->execute(
         $query_id, $query->{fingerprint}, $query->{sample});
   }

PTDEBUG && _d("Saving index usage data");
   my $insert_index_usage_sth = $dbh->prepare(
      "INSERT INTO `$db`.`index_usage` (query_id, db, tbl, idx, cnt) "
      . "VALUES (CONV(?, 16, 10), ?, ?, ?, ?) "
      . "ON DUPLICATE KEY UPDATE cnt = cnt + ?");
   foreach my $query_id ( keys %{$self->{index_usage}} ) {
      foreach my $db ( keys %{$self->{index_usage}->{$query_id}} ) {
         foreach my $tbl ( keys %{$self->{index_usage}->{$query_id}->{$db}} ) {
            my $indexes = $self->{index_usage}->{$query_id}->{$db}->{$tbl};
            foreach my $index ( keys %$indexes ) {
               my $cnt = $indexes->{$index};
               $insert_index_usage_sth->execute(
                  $query_id, $db, $tbl, $index, $cnt, $cnt);
            }
         }
      }
   }

PTDEBUG && _d("Saving alternate index usage data");
   my $insert_index_alt_sth = $dbh->prepare(
      "INSERT INTO `$db`.`index_alternatives` "
      . "(query_id, db, tbl, idx, alt_idx, cnt) "
      . "VALUES (CONV(?, 16, 10), ?, ?, ?, ?, ?) "
      . "ON DUPLICATE KEY UPDATE cnt = cnt + ?");
   foreach my $query_id ( keys %{$self->{alt_index_usage}} ) {
      foreach my $db ( keys %{$self->{alt_index_usage}->{$query_id}} ) {
         foreach my $tbl ( keys %{$self->{alt_index_usage}->{$query_id}->{$db}} ) {
            foreach my $index ( keys %{$self->{alt_index_usage}->{$query_id}->{$db}->{$tbl}} ){
               my $alt_indexes = $self->{alt_index_usage}->{$query_id}->{$db}->{$tbl}->{$index};
               foreach my $alt_index ( keys %$alt_indexes ) {
                  my $cnt = $alt_indexes->{$alt_index};
                  $insert_index_alt_sth->execute(
                     $query_id, $db, $tbl, $index, $alt_index, $cnt, $cnt);
               }
            }
         }
      }
   }

$dbh->commit unless $dbh->{AutoCommit};
   return;
}

1;
}
# ###########################################################################
# End IndexUsage package
# ###########################################################################

# ###########################################################################
# Progress package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/Progress.pm
#   t/lib/Progress.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package Progress;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

sub new {
   my ( $class, %args ) = @_;
   foreach my $arg (qw(jobsize)) {
      die "I need a $arg argument" unless defined $args{$arg};
   }
   if ( (!$args{report} || !$args{interval}) ) {
      if ( $args{spec} && @{$args{spec}} == 2 ) {
         @args{qw(report interval)} = @{$args{spec}};
      }
      else {
         die "I need either report and interval arguments, or a spec";
      }
   }

my $name  = $args{name} || "Progress";
   $args{start} ||= time();
   my $self;
   $self = {
      last_reported => $args{start},
      fraction      => 0,       # How complete the job is
      callback      => sub {
         my ($fraction, $elapsed, $remaining, $eta) = @_;
         printf STDERR "$name: %3d%% %s remain\n",
            $fraction * 100,
            Transformers::secs_to_time($remaining),
            Transformers::ts($eta);
      },
      %args,
   };
   return bless $self, $class;
}

sub validate_spec {
   shift @_ if $_[0] eq 'Progress'; # Permit calling as Progress-> or Progress::
   my ( $spec ) = @_;
   if ( @$spec != 2 ) {
      die "spec array requires a two-part argument\n";
   }
   if ( $spec->[0] !~ m/^(?:percentage|time|iterations)$/ ) {
      die "spec array's first element must be one of "
        . "percentage,time,iterations\n";
   }
   if ( $spec->[1] !~ m/^\d+$/ ) {
      die "spec array's second element must be an integer\n";
   }
}

sub set_callback {
   my ( $self, $callback ) = @_;
   $self->{callback} = $callback;
}

sub start {
   my ( $self, $start ) = @_;
   $self->{start} = $self->{last_reported} = $start || time();
   $self->{first_report} = 0;
}

sub update {
   my ( $self, $callback, %args ) = @_;
   my $jobsize   = $self->{jobsize};
   my $now    ||= $args{now} || time;

$self->{iterations}++; # How many updates have happened;

if ( !$self->{first_report} && $args{first_report} ) {
      $args{first_report}->();
      $self->{first_report} = 1;
   }

if ( $self->{report} eq 'time'
         && $self->{interval} > $now - $self->{last_reported}
   ) {
      return;
   }
   elsif ( $self->{report} eq 'iterations'
         && ($self->{iterations} - 1) % $self->{interval} > 0
   ) {
      return;
   }
   $self->{last_reported} = $now;

my $completed = $callback->();
   $self->{updates}++; # How many times we have run the update callback

return if $completed > $jobsize;

my $fraction = $completed > 0 ? $completed / $jobsize : 0;

if ( $self->{report} eq 'percentage'
         && $self->fraction_modulo($self->{fraction})
            >= $self->fraction_modulo($fraction)
   ) {
      $self->{fraction} = $fraction;
      return;
   }
   $self->{fraction} = $fraction;

my $elapsed   = $now - $self->{start};
   my $remaining = 0;
   my $eta       = $now;
   if ( $completed > 0 && $completed <= $jobsize && $elapsed > 0 ) {
      my $rate = $completed / $elapsed;
      if ( $rate > 0 ) {
         $remaining = ($jobsize - $completed) / $rate;
         $eta       = $now + int($remaining);
      }
   }
   $self->{callback}->($fraction, $elapsed, $remaining, $eta, $completed);
}

sub fraction_modulo {
   my ( $self, $num ) = @_;
   $num *= 100; # Convert from fraction to percentage
   return sprintf('%d',
      sprintf('%d', $num / $self->{interval}) * $self->{interval});
}

1;
}
# ###########################################################################
# End Progress package
# ###########################################################################

# ###########################################################################
# HTTP::Micro package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/HTTP/Micro.pm
#   t/lib/HTTP/Micro.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package HTTP::Micro;

our $VERSION = '0.01';

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use Carp ();

my @attributes;
BEGIN {
    @attributes = qw(agent timeout);
    no strict 'refs';
    for my $accessor ( @attributes ) {
        *{$accessor} = sub {
            @_ > 1 ? $_[0]->{$accessor} = $_[1] : $_[0]->{$accessor};
        };
    }
}

sub new {
    my($class, %args) = @_;
    (my $agent = $class) =~ s{::}{-}g;
    my $self = {
        agent        => $agent . "/" . ($class->VERSION || 0),
        timeout      => 60,
    };
    for my $key ( @attributes ) {
        $self->{$key} = $args{$key} if exists $args{$key}
    }
    return bless $self, $class;
}

my %DefaultPort = (
    http => 80,
    https => 443,
);

sub request {
    my ($self, $method, $url, $args) = @_;
    @_ == 3 || (@_ == 4 && ref $args eq 'HASH')
      or Carp::croak(q/Usage: $http->request(METHOD, URL, [HASHREF])/);
    $args ||= {}; # we keep some state in this during _request

my $response;
    for ( 0 .. 1 ) {
        $response = eval { $self->_request($method, $url, $args) };
        last unless $@ && $method eq 'GET'
            && $@ =~ m{^(?:Socket closed|Unexpected end)};
    }

if (my $e = "$@") {
        $response = {
            success => q{},
            status  => 599,
            reason  => 'Internal Exception',
            content => $e,
            headers => {
                'content-type'   => 'text/plain',
                'content-length' => length $e,
            }
        };
    }
    return $response;
}

sub _request {
    my ($self, $method, $url, $args) = @_;

my ($scheme, $host, $port, $path_query) = $self->_split_url($url);

my $request = {
        method    => $method,
        scheme    => $scheme,
        host_port => ($port == $DefaultPort{$scheme} ? $host : "$host:$port"),
        uri       => $path_query,
        headers   => {},
    };

my $handle  = HTTP::Micro::Handle->new(timeout => $self->{timeout});

$handle->connect($scheme, $host, $port);

$self->_prepare_headers_and_cb($request, $args);
    $handle->write_request_header(@{$request}{qw/method uri headers/});
    $handle->write_content_body($request) if $request->{content};

my $response;
    do { $response = $handle->read_response_header }
        until (substr($response->{status},0,1) ne '1');

if (!($method eq 'HEAD' || $response->{status} =~ /^[23]04/)) {
        $response->{content} = '';
        $handle->read_content_body(sub { $_[1]->{content} .= $_[0] }, $response);
    }

$handle->close;
    $response->{success} = substr($response->{status},0,1) eq '2';
    return $response;
}

sub _prepare_headers_and_cb {
    my ($self, $request, $args) = @_;

for ($args->{headers}) {
        next unless defined;
        while (my ($k, $v) = each %$_) {
            $request->{headers}{lc $k} = $v;
        }
    }
    $request->{headers}{'host'}         = $request->{host_port};
    $request->{headers}{'connection'}   = "close";
    $request->{headers}{'user-agent'} ||= $self->{agent};

if (defined $args->{content}) {
        $request->{headers}{'content-type'} ||= "application/octet-stream";
        utf8::downgrade($args->{content}, 1)
            or Carp::croak(q/Wide character in request message body/);
        $request->{headers}{'content-length'} = length $args->{content};
        $request->{content} = $args->{content};
    }
    return;
}

sub _split_url {
    my $url = pop;

my ($scheme, $authority, $path_query) = $url =~ m<\A([^:/?#]+)://([^/?#]*)([^#]*)>
      or Carp::croak(qq/Cannot parse URL: '$url'/);

$scheme     = lc $scheme;
    $path_query = "/$path_query" unless $path_query =~ m<\A/>;

my $host = (length($authority)) ? lc $authority : 'localhost';
       $host =~ s/\A[^@]*@//;   # userinfo
    my $port = do {
       $host =~ s/:([0-9]*)\z// && length $1
         ? $1
         : $DefaultPort{$scheme}
    };

return ($scheme, $host, $port, $path_query);
}

} # HTTP::Micro

{
   package HTTP::Micro::Handle;

use strict;
   use warnings FATAL => 'all';
   use English qw(-no_match_vars);

use Carp       qw(croak);
   use Errno      qw(EINTR EPIPE);
   use IO::Socket qw(SOCK_STREAM);

sub BUFSIZE () { 32768 }

my $Printable = sub {
       local $_ = shift;
       s/\r/\\r/g;
       s/\n/\\n/g;
       s/\t/\\t/g;
       s/([^\x20-\x7E])/sprintf('\\x%.2X', ord($1))/ge;
       $_;
   };

sub new {
       my ($class, %args) = @_;
       return bless {
           rbuf          => '',
           timeout       => 60,
           max_line_size => 16384,
           %args
       }, $class;
   }

my $ssl_verify_args = {
       check_cn         => "when_only",
       wildcards_in_alt => "anywhere",
       wildcards_in_cn  => "anywhere"
   };

sub connect {
       @_ == 4 || croak(q/Usage: $handle->connect(scheme, host, port)/);
       my ($self, $scheme, $host, $port) = @_;

if ( $scheme eq 'https' ) {
           eval "require IO::Socket::SSL"
               unless exists $INC{'IO/Socket/SSL.pm'};
           croak(qq/IO::Socket::SSL must be installed for https support\n/)
               unless $INC{'IO/Socket/SSL.pm'};
       }
       elsif ( $scheme ne 'http' ) {
         croak(qq/Unsupported URL scheme '$scheme'\n/);
       }

$self->{fh} = IO::Socket::INET->new(
           PeerHost  => $host,
           PeerPort  => $port,
           Proto     => 'tcp',
           Type      => SOCK_STREAM,
           Timeout   => $self->{timeout}
       ) or croak(qq/Could not connect to '$host:$port': $@/);

binmode($self->{fh})
         or croak(qq/Could not binmode() socket: '$!'/);

if ( $scheme eq 'https') {
           IO::Socket::SSL->start_SSL($self->{fh});
           ref($self->{fh}) eq 'IO::Socket::SSL'
               or die(qq/SSL connection failed for $host\n/);
           if ( $self->{fh}->can("verify_hostname") ) {
               $self->{fh}->verify_hostname( $host, $ssl_verify_args )
                  or die(qq/SSL certificate not valid for $host\n/);
           }
           else {
            my $fh = $self->{fh};
            _verify_hostname_of_cert($host, _peer_certificate($fh), $ssl_verify_args)
                  or die(qq/SSL certificate not valid for $host\n/);
            }
       }
         
       $self->{host} = $host;
       $self->{port} = $port;

return $self;
   }

sub close {
       @_ == 1 || croak(q/Usage: $handle->close()/);
       my ($self) = @_;
       CORE::close($self->{fh})
         or croak(qq/Could not close socket: '$!'/);
   }

sub write {
       @_ == 2 || croak(q/Usage: $handle->write(buf)/);
       my ($self, $buf) = @_;

my $len = length $buf;
       my $off = 0;

local $SIG{PIPE} = 'IGNORE';

while () {
           $self->can_write
             or croak(q/Timed out while waiting for socket to become ready for writing/);
           my $r = syswrite($self->{fh}, $buf, $len, $off);
           if (defined $r) {
               $len -= $r;
               $off += $r;
               last unless $len > 0;
           }
           elsif ($! == EPIPE) {
               croak(qq/Socket closed by remote server: $!/);
           }
           elsif ($! != EINTR) {
               croak(qq/Could not write to socket: '$!'/);
           }
       }
       return $off;
   }

sub read {
       @_ == 2 || @_ == 3 || croak(q/Usage: $handle->read(len)/);
       my ($self, $len) = @_;

my $buf  = '';
       my $got = length $self->{rbuf};

if ($got) {
           my $take = ($got < $len) ? $got : $len;
           $buf  = substr($self->{rbuf}, 0, $take, '');
           $len -= $take;
       }

while ($len > 0) {
           $self->can_read
             or croak(q/Timed out while waiting for socket to become ready for reading/);
           my $r = sysread($self->{fh}, $buf, $len, length $buf);
           if (defined $r) {
               last unless $r;
               $len -= $r;
           }
           elsif ($! != EINTR) {
               croak(qq/Could not read from socket: '$!'/);
           }
       }
       if ($len) {
           croak(q/Unexpected end of stream/);
       }
       return $buf;
   }

sub readline {
       @_ == 1 || croak(q/Usage: $handle->readline()/);
       my ($self) = @_;

while () {
           if ($self->{rbuf} =~ s/\A ([^\x0D\x0A]* \x0D?\x0A)//x) {
               return $1;
           }
           $self->can_read
             or croak(q/Timed out while waiting for socket to become ready for reading/);
           my $r = sysread($self->{fh}, $self->{rbuf}, BUFSIZE, length $self->{rbuf});
           if (defined $r) {
               last unless $r;
           }
           elsif ($! != EINTR) {
               croak(qq/Could not read from socket: '$!'/);
           }
       }
       croak(q/Unexpected end of stream while looking for line/);
   }

sub read_header_lines {
       @_ == 1 || @_ == 2 || croak(q/Usage: $handle->read_header_lines([headers])/);
       my ($self, $headers) = @_;
       $headers ||= {};
       my $lines   = 0;
       my $val;

while () {
            my $line = $self->readline;

if ($line =~ /\A ([^\x00-\x1F\x7F:]+) : [\x09\x20]* ([^\x0D\x0A]*)/x) {
                my ($field_name) = lc $1;
                $val = \($headers->{$field_name} = $2);
            }
            elsif ($line =~ /\A [\x09\x20]+ ([^\x0D\x0A]*)/x) {
                $val
                  or croak(q/Unexpected header continuation line/);
                next unless length $1;
                $$val .= ' ' if length $$val;
                $$val .= $1;
            }
            elsif ($line =~ /\A \x0D?\x0A \z/x) {
               last;
            }
            else {
               croak(q/Malformed header line: / . $Printable->($line));
            }
       }
       return $headers;
   }

sub write_header_lines {
       (@_ == 2 && ref $_[1] eq 'HASH') || croak(q/Usage: $handle->write_header_lines(headers)/);
       my($self, $headers) = @_;

my $buf = '';
       while (my ($k, $v) = each %$headers) {
           my $field_name = lc $k;
            $field_name =~ /\A [\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7A\x7C\x7E]+ \z/x
               or croak(q/Invalid HTTP header field name: / . $Printable->($field_name));
            $field_name =~ s/\b(\w)/\u$1/g;
            $buf .= "$field_name: $v\x0D\x0A";
       }
       $buf .= "\x0D\x0A";
       return $self->write($buf);
   }

sub read_content_body {
       @_ == 3 || @_ == 4 || croak(q/Usage: $handle->read_content_body(callback, response, [read_length])/);
       my ($self, $cb, $response, $len) = @_;
       $len ||= $response->{headers}{'content-length'};

croak("No content-length in the returned response, and this "
           . "UA doesn't implement chunking") unless defined $len;

while ($len > 0) {
           my $read = ($len > BUFSIZE) ? BUFSIZE : $len;
           $cb->($self->read($read), $response);
           $len -= $read;
       }

return;
   }

sub write_content_body {
       @_ == 2 || croak(q/Usage: $handle->write_content_body(request)/);
       my ($self, $request) = @_;
       my ($len, $content_length) = (0, $request->{headers}{'content-length'});

$len += $self->write($request->{content});

$len == $content_length
         or croak(qq/Content-Length missmatch (got: $len expected: $content_length)/);

return $len;
   }

sub read_response_header {
       @_ == 1 || croak(q/Usage: $handle->read_response_header()/);
       my ($self) = @_;

my $line = $self->readline;

$line =~ /\A (HTTP\/(0*\d+\.0*\d+)) [\x09\x20]+ ([0-9]{3}) [\x09\x20]+ ([^\x0D\x0A]*) \x0D?\x0A/x
         or croak(q/Malformed Status-Line: / . $Printable->($line));

my ($protocol, $version, $status, $reason) = ($1, $2, $3, $4);

return {
           status   => $status,
           reason   => $reason,
           headers  => $self->read_header_lines,
           protocol => $protocol,
       };
   }

sub write_request_header {
       @_ == 4 || croak(q/Usage: $handle->write_request_header(method, request_uri, headers)/);
       my ($self, $method, $request_uri, $headers) = @_;

return $self->write("$method $request_uri HTTP/1.1\x0D\x0A")
            + $self->write_header_lines($headers);
   }

sub _do_timeout {
       my ($self, $type, $timeout) = @_;
       $timeout = $self->{timeout}
           unless defined $timeout && $timeout >= 0;

my $fd = fileno $self->{fh};
       defined $fd && $fd >= 0
         or croak(q/select(2): 'Bad file descriptor'/);

my $initial = time;
       my $pending = $timeout;
       my $nfound;

vec(my $fdset = '', $fd, 1) = 1;

while () {
           $nfound = ($type eq 'read')
               ? select($fdset, undef, undef, $pending)
               : select(undef, $fdset, undef, $pending) ;
           if ($nfound == -1) {
               $! == EINTR
                 or croak(qq/select(2): '$!'/);
               redo if !$timeout || ($pending = $timeout - (time - $initial)) > 0;
               $nfound = 0;
           }
           last;
       }
       $! = 0;
       return $nfound;
   }

sub can_read {
       @_ == 1 || @_ == 2 || croak(q/Usage: $handle->can_read([timeout])/);
       my $self = shift;
       return $self->_do_timeout('read', @_)
   }

sub can_write {
       @_ == 1 || @_ == 2 || croak(q/Usage: $handle->can_write([timeout])/);
       my $self = shift;
       return $self->_do_timeout('write', @_)
   }
}  # HTTP::Micro::Handle

my $prog = <<'EOP';
BEGIN {
   if ( defined &IO::Socket::SSL::CAN_IPV6 ) {
      *CAN_IPV6 = \*IO::Socket::SSL::CAN_IPV6;
   }
   else {
      constant->import( CAN_IPV6 => '' );
   }
   my %const = (
      NID_CommonName => 13,
      GEN_DNS => 2,
      GEN_IPADD => 7,
   );
   while ( my ($name,$value) = each %const ) {
      no strict 'refs';
      *{$name} = UNIVERSAL::can( 'Net::SSLeay', $name ) || sub { $value };
   }
}
{
   use Carp qw(croak);
   my %dispatcher = (
      issuer =>  sub { Net::SSLeay::X509_NAME_oneline( Net::SSLeay::X509_get_issuer_name( shift )) },
      subject => sub { Net::SSLeay::X509_NAME_oneline( Net::SSLeay::X509_get_subject_name( shift )) },
   );
   if ( $Net::SSLeay::VERSION >= 1.30 ) {
      $dispatcher{commonName} = sub {
         my $cn = Net::SSLeay::X509_NAME_get_text_by_NID(
            Net::SSLeay::X509_get_subject_name( shift ), NID_CommonName);
         $cn =~s{\0$}{}; # work around Bug in Net::SSLeay <1.33
         $cn;
      }
   } else {
      $dispatcher{commonName} = sub {
         croak "you need at least Net::SSLeay version 1.30 for getting commonName"
      }
   }

if ( $Net::SSLeay::VERSION >= 1.33 ) {
      $dispatcher{subjectAltNames} = sub { Net::SSLeay::X509_get_subjectAltNames( shift ) };
   } else {
      $dispatcher{subjectAltNames} = sub {
         return;
      };
   }

$dispatcher{authority} = $dispatcher{issuer};
   $dispatcher{owner}     = $dispatcher{subject};
   $dispatcher{cn}        = $dispatcher{commonName};

sub _peer_certificate {
      my ($self, $field) = @_;
      my $ssl = $self->_get_ssl_object or return;

my $cert = ${*$self}{_SSL_certificate}
         ||= Net::SSLeay::get_peer_certificate($ssl)
         or return $self->error("Could not retrieve peer certificate");

if ($field) {
         my $sub = $dispatcher{$field} or croak
            "invalid argument for peer_certificate, valid are: ".join( " ",keys %dispatcher ).
            "\nMaybe you need to upgrade your Net::SSLeay";
         return $sub->($cert);
      } else {
         return $cert
      }
   }

my %scheme = (
      ldap => {
         wildcards_in_cn    => 0,
         wildcards_in_alt => 'leftmost',
         check_cn         => 'always',
      },
      http => {
         wildcards_in_cn    => 'anywhere',
         wildcards_in_alt => 'anywhere',
         check_cn         => 'when_only',
      },
      smtp => {
         wildcards_in_cn    => 0,
         wildcards_in_alt => 0,
         check_cn         => 'always'
      },
      none => {}, # do not check
   );

$scheme{www}  = $scheme{http}; # alias
   $scheme{xmpp} = $scheme{http}; # rfc 3920
   $scheme{pop3} = $scheme{ldap}; # rfc 2595
   $scheme{imap} = $scheme{ldap}; # rfc 2595
   $scheme{acap} = $scheme{ldap}; # rfc 2595
   $scheme{nntp} = $scheme{ldap}; # rfc 4642
   $scheme{ftp}  = $scheme{http}; # rfc 4217

sub _verify_hostname_of_cert {
      my $identity = shift;
      my $cert = shift;
      my $scheme = shift || 'none';
      if ( ! ref($scheme) ) {
         $scheme = $scheme{$scheme} or croak "scheme $scheme not defined";
      }

return 1 if ! %$scheme; # 'none'

my $commonName = $dispatcher{cn}->($cert);
      my @altNames   = $dispatcher{subjectAltNames}->($cert);

if ( my $sub = $scheme->{callback} ) {
         return $sub->($identity,$commonName,@altNames);
      }

my $ipn;
      if ( CAN_IPV6 and $identity =~m{:} ) {
         $ipn = IO::Socket::SSL::inet_pton(IO::Socket::SSL::AF_INET6,$identity)
            or croak "'$identity' is not IPv6, but neither IPv4 nor hostname";
      } elsif ( $identity =~m{^\d+\.\d+\.\d+\.\d+$} ) {
         $ipn = IO::Socket::SSL::inet_aton( $identity ) or croak "'$identity' is not IPv4, but neither IPv6 nor hostname";
      } else {
         if ( $identity =~m{[^a-zA-Z0-9_.\-]} ) {
            $identity =~m{\0} and croak("name '$identity' has \\0 byte");
            $identity = IO::Socket::SSL::idn_to_ascii($identity) or
               croak "Warning: Given name '$identity' could not be converted to IDNA!";
         }
      }

my $check_name = sub {
         my ($name,$identity,$wtyp) = @_;
         $wtyp ||= '';
         my $pattern;
         if ( $wtyp eq 'anywhere' and $name =~m{^([a-zA-Z0-9_\-]*)\*(.+)} ) {
            $pattern = qr{^\Q$1\E[a-zA-Z0-9_\-]*\Q$2\E$}i;
         } elsif ( $wtyp eq 'leftmost' and $name =~m{^\*(\..+)$} ) {
            $pattern = qr{^[a-zA-Z0-9_\-]*\Q$1\E$}i;
         } else {
            $pattern = qr{^\Q$name\E$}i;
         }
         return $identity =~ $pattern;
      };

my $alt_dnsNames = 0;
      while (@altNames) {
         my ($type, $name) = splice (@altNames, 0, 2);
         if ( $ipn and $type == GEN_IPADD ) {
            return 1 if $ipn eq $name;

} elsif ( ! $ipn and $type == GEN_DNS ) {
            $name =~s/\s+$//; $name =~s/^\s+//;
            $alt_dnsNames++;
            $check_name->($name,$identity,$scheme->{wildcards_in_alt})
               and return 1;
         }
      }

if ( ! $ipn and (
         $scheme->{check_cn} eq 'always' or
         $scheme->{check_cn} eq 'when_only' and !$alt_dnsNames)) {
         $check_name->($commonName,$identity,$scheme->{wildcards_in_cn})
            and return 1;
      }

return 0; # no match
   }
}
EOP

eval { require IO::Socket::SSL };
if ( $INC{"IO/Socket/SSL.pm"} ) {
   eval $prog;
   die $@ if $@;
}

1;
# ###########################################################################
# End HTTP::Micro package
# ###########################################################################

# ###########################################################################
# VersionCheck package
# This package is a copy without comments from the original.  The original
# with comments and its test file can be found in the Bazaar repository at,
#   lib/VersionCheck.pm
#   t/lib/VersionCheck.t
# See https://launchpad.net/percona-toolkit for more information.
# ###########################################################################
{
package VersionCheck;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);

use constant PTDEBUG => $ENV{PTDEBUG} || 0;

use Data::Dumper;
local $Data::Dumper::Indent    = 1;
local $Data::Dumper::Sortkeys  = 1;
local $Data::Dumper::Quotekeys = 0;

use Digest::MD5 qw(md5_hex);
use Sys::Hostname qw(hostname);
use File::Basename qw();
use File::Spec;
use FindBin qw();

eval {
   require Percona::Toolkit;
   require HTTP::Micro;
};

{
   my $file    = 'percona-version-check';
   my $home    = $ENV{HOME} || $ENV{HOMEPATH} || $ENV{USERPROFILE} || '.';
   my @vc_dirs = (
      '/etc/percona',
      '/etc/percona-toolkit',
      '/tmp',
      "$home",
   );

sub version_check_file {
      foreach my $dir ( @vc_dirs ) {
         if ( -d $dir && -w $dir ) {
            PTDEBUG && _d('Version check file', $file, 'in', $dir);
            return $dir . '/' . $file;
         }
      }
      PTDEBUG && _d('Version check file', $file, 'in', $ENV{PWD});
      return $file;  # in the CWD
   } 
}

sub version_check_time_limit {
   return 60 * 60 * 24;  # one day
}

sub version_check {
   my (%args) = @_;

my $instances = $args{instances} || [];
   my $instances_to_check;

PTDEBUG && _d('FindBin::Bin:', $FindBin::Bin);
   if ( !$args{force} ) {
      if ( $FindBin::Bin
           && (-d "$FindBin::Bin/../.bzr"    || 
               -d "$FindBin::Bin/../../.bzr" ||
               -d "$FindBin::Bin/../.git"    || 
               -d "$FindBin::Bin/../../.git" 
              ) 
         ) {
         PTDEBUG && _d("$FindBin::Bin/../.bzr disables --version-check");
         return;
      }
   }

eval {
      foreach my $instance ( @$instances ) {
         my ($name, $id) = get_instance_id($instance);
         $instance->{name} = $name;
         $instance->{id}   = $id;
      }

push @$instances, { name => 'system', id => 0 };

$instances_to_check = get_instances_to_check(
         instances => $instances,
         vc_file   => $args{vc_file},  # testing
         now       => $args{now},      # testing
      );
      PTDEBUG && _d(scalar @$instances_to_check, 'instances to check');
      return unless @$instances_to_check;

my $protocol = 'https';  
      eval { require IO::Socket::SSL; };
      if ( $EVAL_ERROR ) {
         PTDEBUG && _d($EVAL_ERROR);
         PTDEBUG && _d("SSL not available, won't run version_check");
         return;
      }
      PTDEBUG && _d('Using', $protocol);

my $advice = pingback(
         instances => $instances_to_check,
         protocol  => $protocol,
         url       => $args{url}                       # testing
                   || $ENV{PERCONA_VERSION_CHECK_URL}  # testing
                   || "$protocol://v.percona.com",
      );
      if ( $advice ) {
         PTDEBUG && _d('Advice:', Dumper($advice));
         if ( scalar @$advice > 1) {
            print "\n# " . scalar @$advice . " software updates are "
               . "available:\n";
         }
         else {
            print "\n# A software update is available:\n";
         }
         print join("\n", map { "#   * $_" } @$advice), "\n\n";
      }
   };
   if ( $EVAL_ERROR ) {
      PTDEBUG && _d('Version check failed:', $EVAL_ERROR);
   }

if ( @$instances_to_check ) {
      eval {
         update_check_times(
            instances => $instances_to_check,
            vc_file   => $args{vc_file},  # testing
            now       => $args{now},      # testing
         );
      };
      if ( $EVAL_ERROR ) {
         PTDEBUG && _d('Error updating version check file:', $EVAL_ERROR);
      }
   }

if ( $ENV{PTDEBUG_VERSION_CHECK} ) {
      warn "Exiting because the PTDEBUG_VERSION_CHECK "
         . "environment variable is defined.\n";
      exit 255;
   }

return;
}

sub get_instances_to_check {
   my (%args) = @_;

my $instances = $args{instances};
   my $now       = $args{now}     || int(time);
   my $vc_file   = $args{vc_file} || version_check_file();

if ( !-f $vc_file ) {
      PTDEBUG && _d('Version check file', $vc_file, 'does not exist;',
         'version checking all instances');
      return $instances;
   }

open my $fh, '<', $vc_file or die "Cannot open $vc_file: $OS_ERROR";
   chomp(my $file_contents = do { local $/ = undef; <$fh> });
   PTDEBUG && _d('Version check file', $vc_file, 'contents:', $file_contents);
   close $fh;
   my %last_check_time_for = $file_contents =~ /^([^,]+),(.+)$/mg;

my $check_time_limit = version_check_time_limit();
   my @instances_to_check;
   foreach my $instance ( @$instances ) {
      my $last_check_time = $last_check_time_for{ $instance->{id} };
      PTDEBUG && _d('Intsance', $instance->{id}, 'last checked',
         $last_check_time, 'now', $now, 'diff', $now - ($last_check_time || 0),
         'hours until next check',
         sprintf '%.2f',
            ($check_time_limit - ($now - ($last_check_time || 0))) / 3600);
      if ( !defined $last_check_time
           || ($now - $last_check_time) >= $check_time_limit ) {
         PTDEBUG && _d('Time to check', Dumper($instance));
         push @instances_to_check, $instance;
      }
   }

return \@instances_to_check;
}

sub update_check_times {
   my (%args) = @_;

my $instances = $args{instances};
   my $now       = $args{now}     || int(time);
   my $vc_file   = $args{vc_file} || version_check_file();
   PTDEBUG && _d('Updating last check time:', $now);

my %all_instances = map {
      $_->{id} => { name => $_->{name}, ts => $now }
   } @$instances;

if ( -f $vc_file ) {
      open my $fh, '<', $vc_file or die "Cannot read $vc_file: $OS_ERROR";
      my $contents = do { local $/ = undef; <$fh> };
      close $fh;

foreach my $line ( split("\n", ($contents || '')) ) {
         my ($id, $ts) = split(',', $line);
         if ( !exists $all_instances{$id} ) {
            $all_instances{$id} = { ts => $ts };  # original ts, not updated
         }
      }
   }

open my $fh, '>', $vc_file or die "Cannot write to $vc_file: $OS_ERROR";
   foreach my $id ( sort keys %all_instances ) {
      PTDEBUG && _d('Updated:', $id, Dumper($all_instances{$id}));
      print { $fh } $id . ',' . $all_instances{$id}->{ts} . "\n";
   }
   close $fh;

return;
}

sub get_instance_id {
   my ($instance) = @_;

my $dbh = $instance->{dbh};
   my $dsn = $instance->{dsn};

my $sql = q{SELECT CONCAT(@@hostname, @@port)};
   PTDEBUG && _d($sql);
   my ($name) = eval { $dbh->selectrow_array($sql) };
   if ( $EVAL_ERROR ) {
      PTDEBUG && _d($EVAL_ERROR);
      $sql = q{SELECT @@hostname};
      PTDEBUG && _d($sql);
      ($name) = eval { $dbh->selectrow_array($sql) };
      if ( $EVAL_ERROR ) {
         PTDEBUG && _d($EVAL_ERROR);
         $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
      }
      else {
         $sql = q{SHOW VARIABLES LIKE 'port'};
         PTDEBUG && _d($sql);
         my (undef, $port) = eval { $dbh->selectrow_array($sql) };
         PTDEBUG && _d('port:', $port);
         $name .= $port || '';
      }
   }
   my $id = md5_hex($name);

PTDEBUG && _d('MySQL instance:', $id, $name, Dumper($dsn));

return $name, $id;
}

sub pingback {
   my (%args) = @_;
   my @required_args = qw(url instances);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my $url       = $args{url};
   my $instances = $args{instances};

my $ua = $args{ua} || HTTP::Micro->new( timeout => 3 );

my $response = $ua->request('GET', $url);
   PTDEBUG && _d('Server response:', Dumper($response));
   die "No response from GET $url"
      if !$response;
   die("GET on $url returned HTTP status $response->{status}; expected 200\n",
       ($response->{content} || '')) if $response->{status} != 200;
   die("GET on $url did not return any programs to check")
      if !$response->{content};

my $items = parse_server_response(
      response => $response->{content}
   );
   die "Failed to parse server requested programs: $response->{content}"
      if !scalar keys %$items;
      
   my $versions = get_versions(
      items     => $items,
      instances => $instances,
   );
   die "Failed to get any program versions; should have at least gotten Perl"
      if !scalar keys %$versions;

my $client_content = encode_client_response(
      items      => $items,
      versions   => $versions,
      general_id => md5_hex( hostname() ),
   );

my $client_response = {
      headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
      content => $client_content,
   };
   PTDEBUG && _d('Client response:', Dumper($client_response));

$response = $ua->request('POST', $url, $client_response);
   PTDEBUG && _d('Server suggestions:', Dumper($response));
   die "No response from POST $url $client_response"
      if !$response;
   die "POST $url returned HTTP status $response->{status}; expected 200"
      if $response->{status} != 200;

return unless $response->{content};

$items = parse_server_response(
      response   => $response->{content},
      split_vars => 0,
   );
   die "Failed to parse server suggestions: $response->{content}"
      if !scalar keys %$items;
   my @suggestions = map { $_->{vars} }
                     sort { $a->{item} cmp $b->{item} }
                     values %$items;

return \@suggestions;
}

sub encode_client_response {
   my (%args) = @_;
   my @required_args = qw(items versions general_id);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($items, $versions, $general_id) = @args{@required_args};

my @lines;
   foreach my $item ( sort keys %$items ) {
      next unless exists $versions->{$item};
      if ( ref($versions->{$item}) eq 'HASH' ) {
         my $mysql_versions = $versions->{$item};
         for my $id ( sort keys %$mysql_versions ) {
            push @lines, join(';', $id, $item, $mysql_versions->{$id});
         }
      }
      else {
         push @lines, join(';', $general_id, $item, $versions->{$item});
      }
   }

my $client_response = join("\n", @lines) . "\n";
   return $client_response;
}

sub parse_server_response {
   my (%args) = @_;
   my @required_args = qw(response);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($response) = @args{@required_args};

my %items = map {
      my ($item, $type, $vars) = split(";", $_);
      if ( !defined $args{split_vars} || $args{split_vars} ) {
         $vars = [ split(",", ($vars || '')) ];
      }
      $item => {
         item => $item,
         type => $type,
         vars => $vars,
      };
   } split("\n", $response);

PTDEBUG && _d('Items:', Dumper(\%items));

return \%items;
}

my %sub_for_type = (
   os_version          => \&get_os_version,
   perl_version        => \&get_perl_version,
   perl_module_version => \&get_perl_module_version,
   mysql_variable      => \&get_mysql_variable,
);

sub valid_item {
   my ($item) = @_;
   return unless $item;
   if ( !exists $sub_for_type{ $item->{type} } ) {
      PTDEBUG && _d('Invalid type:', $item->{type});
      return 0;
   }
   return 1;
}

sub get_versions {
   my (%args) = @_;
   my @required_args = qw(items);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($items) = @args{@required_args};

my %versions;
   foreach my $item ( values %$items ) {
      next unless valid_item($item);
      eval {
         my $version = $sub_for_type{ $item->{type} }->(
            item      => $item,
            instances => $args{instances},
         );
         if ( $version ) {
            chomp $version unless ref($version);
            $versions{$item->{item}} = $version;
         }
      };
      if ( $EVAL_ERROR ) {
         PTDEBUG && _d('Error getting version for', Dumper($item), $EVAL_ERROR);
      }
   }

return \%versions;
}

sub get_os_version {
   if ( $OSNAME eq 'MSWin32' ) {
      require Win32;
      return Win32::GetOSDisplayName();
   }

chomp(my $platform = `uname -s`);
  PTDEBUG && _d('platform:', $platform);
  return $OSNAME unless $platform;

chomp(my $lsb_release
            = `which lsb_release 2>/dev/null | awk '{print \$1}'` || '');
   PTDEBUG && _d('lsb_release:', $lsb_release);

my $release = "";

if ( $platform eq 'Linux' ) {
      if ( -f "/etc/fedora-release" ) {
         $release = `cat /etc/fedora-release`;
      }
      elsif ( -f "/etc/redhat-release" ) {
         $release = `cat /etc/redhat-release`;
      }
      elsif ( -f "/etc/system-release" ) {
         $release = `cat /etc/system-release`;
      }
      elsif ( $lsb_release ) {
         $release = `$lsb_release -ds`;
      }
      elsif ( -f "/etc/lsb-release" ) {
         $release = `grep DISTRIB_DESCRIPTION /etc/lsb-release`;
         $release =~ s/^\w+="([^"]+)".+/$1/;
      }
      elsif ( -f "/etc/debian_version" ) {
         chomp(my $rel = `cat /etc/debian_version`);
         $release = "Debian $rel";
         if ( -f "/etc/apt/sources.list" ) {
             chomp(my $code_name = `awk '/^deb/ {print \$3}' /etc/apt/sources.list | awk -F/ '{print \$1}'| awk 'BEGIN {FS="|"} {print \$1}' | sort | uniq -c | sort -rn | head -n1 | awk '{print \$2}'`);
             $release .= " ($code_name)" if $code_name;
         }
      }
      elsif ( -f "/etc/os-release" ) { # openSUSE
         chomp($release = `grep PRETTY_NAME /etc/os-release`);
         $release =~ s/^PRETTY_NAME="(.+)"$/$1/;
      }
      elsif ( `ls /etc/*release 2>/dev/null` ) {
         if ( `grep DISTRIB_DESCRIPTION /etc/*release 2>/dev/null` ) {
            $release = `grep DISTRIB_DESCRIPTION /etc/*release | head -n1`;
         }
         else {
            $release = `cat /etc/*release | head -n1`;
         }
      }
   }
   elsif ( $platform =~ m/(?:BSD|^Darwin)$/ ) {
      my $rel = `uname -r`;
      $release = "$platform $rel";
   }
   elsif ( $platform eq "SunOS" ) {
      my $rel = `head -n1 /etc/release` || `uname -r`;
      $release = "$platform $rel";
   }

if ( !$release ) {
      PTDEBUG && _d('Failed to get the release, using platform');
      $release = $platform;
   }
   chomp($release);

$release =~ s/^"|"$//g;

PTDEBUG && _d('OS version =', $release);
   return $release;
}

sub get_perl_version {
   my (%args) = @_;
   my $item = $args{item};
   return unless $item;

my $version = sprintf '%vd', $PERL_VERSION;
   PTDEBUG && _d('Perl version', $version);
   return $version;
}

sub get_perl_module_version {
   my (%args) = @_;
   my $item = $args{item};
   return unless $item;

my $var     = '$' . $item->{item} . '::VERSION';
   my $version = eval "use $item->{item}; $var;";
   PTDEBUG && _d('Perl version for', $var, '=', $version);
   return $version;
}

sub get_mysql_variable {
   return get_from_mysql(
      show => 'VARIABLES',
      @_,
   );
}

sub get_from_mysql {
   my (%args) = @_;
   my $show      = $args{show};
   my $item      = $args{item};
   my $instances = $args{instances};
   return unless $show && $item;

if ( !$instances || !@$instances ) {
      PTDEBUG && _d('Cannot check', $item,
         'because there are no MySQL instances');
      return;
   }

if ($item->{item} eq 'MySQL' && $item->{type} eq 'mysql_variable') {
      @{$item->{vars}} = grep { $_ eq 'version' || $_ eq 'version_comment' } @{$item->{vars}};
   }

my @versions;
   my %version_for;
   foreach my $instance ( @$instances ) {
      next unless $instance->{id};  # special system instance has id=0
      my $dbh = $instance->{dbh};
      local $dbh->{FetchHashKeyName} = 'NAME_lc';
      my $sql = qq/SHOW $show/;
      PTDEBUG && _d($sql);
      my $rows = $dbh->selectall_hashref($sql, 'variable_name');

my @versions;
      foreach my $var ( @{$item->{vars}} ) {
         $var = lc($var);
         my $version = $rows->{$var}->{value};
         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
            'on', $instance->{name});
         push @versions, $version;
      }
      $version_for{ $instance->{id} } = join(' ', @versions);
   }

return \%version_for;
}

1;
}
# ###########################################################################
# End VersionCheck package
# ###########################################################################

# ###########################################################################
# This is a combination of modules and programs in one -- a runnable module.
# http://www.perl.com/pub/a/2006/07/13/lightning-articles.html?page=last
# Or, look it up in the Camel book on pages 642 and 643 in the 3rd edition.
#
# Check just above main() for the call to main() which actually runs the
# program.
# ###########################################################################
package pt_index_usage;

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use Data::Dumper;
$Data::Dumper::Indent = 1;
$OUTPUT_AUTOFLUSH     = 1;

use Percona::Toolkit;
use constant PTDEBUG => $ENV{PTDEBUG} || 0;

Transformers->import(qw(make_checksum));

# Global variables.  Only really essential variables should be here.
my $oktorun = 1;

sub main {
   local @ARGV = @_;  # set global ARGV for this package

$oktorun = 1;

# ##########################################################################
   # Get configuration information.
   # ##########################################################################
   my $o = new OptionParser();
   $o->get_specs();
   $o->get_opts();
   my $dp = $o->DSNParser();
   $dp->prop('set-vars', $o->set_vars());
   $o->set('progress', undef) if $o->get('q');

if ( !$o->got('help') ) {
      if ( $o->get('progress') ) {
         eval { Progress->validate_spec($o->get('progress')) };
         if ( $EVAL_ERROR ) {
            chomp $EVAL_ERROR;
            $o->save_error("--progress $EVAL_ERROR");
         }
      }

if ( my $dsn = $o->get('save-results-database') ) {
         if ( !$dsn->{D} ) {
            $o->save_error("You must specify a D (database) part for the "
               . "--save-results-database DSN");
         }
      }
   }

$o->usage_or_errors();

# ##########################################################################
   # Open the database connections.  If no connection opts (-h, -P, etc.)
   # are given on the cmd line then parse_options() will return undef,
   # but get_cxn() required a defined dsn arg so use an empty hashref.
   # ########################################################################## 
   my ($dsn, $dbh, $si_dbh, $res_dbh);
   my $res_dsn;
   my $res_db;
   eval {
      $dsn = $dp->parse_options($o) || {};

# dbh for EXPLAIN-ing.
      $dbh = get_cxn(
         dsn          => $dsn,
         OptionParser => $o,
         DSNParser    => $dp,
      );

# dbh for SchemaIterator
      # http://code.google.com/p/maatkit/issues/detail?id=1140 
      $si_dbh = get_cxn(
         dsn          => $dsn,
         OptionParser => $o,
         DSNParser    => $dp,
      );

# dbh for --save-results-database
      if ( $res_dsn = $o->get('save-results-database') ) {
         
         # To make --create-save-results-database work we have to
         # temporarily remove the D from the DSN to avoid the error
         # "DBI connect failed: Unknown database".  It's restored
         # to the DSN after connecting.
         $res_db       = $res_dsn->{D};
         $res_dsn->{D} = undef if $o->get('create-save-results-database');

$res_dbh = get_cxn(
            dsn          => $res_dsn,
            OptionParser => $o,
            DSNParser    => $dp,
         );

$res_dsn->{D} = $res_db;
      }
   };
   if ( $EVAL_ERROR ) {
      # Avoid "Issuing rollback() for database handle being DESTROY'd
      # without explicit disconnect()" errors.
      $dbh->disconnect if $dbh;
      $si_dbh->disconnect if $si_dbh;
      $res_dbh->disconnect if $res_dbh;
      die $EVAL_ERROR;
   }

# ##########################################################################
   # Make common modules.
   # ##########################################################################
   my $q      = new Quoter();
   my $qp     = new QueryParser();
   my $qr     = new QueryRewriter(QueryParser => $qp);
   my $tp     = new TableParser(Quoter => $q);
   my $parser = new SlowLogParser();
   my $fi     = new FileIterator();
   my $iu     = new IndexUsage(
      QueryRewriter => $qr,
   );
   my $exa    = new ExplainAnalyzer(
      QueryRewriter => $qr,
      QueryParser   => $qp
   );
   my %common_modules = (
      OptionParser    => $o,
      DSNParser       => $dp,
      Quoter          => $q,
      QueryParser     => $qp,
      QueryRewriter   => $qr,
      TableParser     => $tp,
      IndexUsage      => $iu,
      ExplainAnalyzer => $exa,
   );

# ########################################################################
   # Ready the save results database and its tables.
   # ########################################################################
   if ( $res_dbh ) {
      my $db = $o->get('save-results-database')->{D};  # checked earlier

# Create the database (if it doesn't already exist).
      if ( $o->get('create-save-results-database') ) {
         create_save_results_database(
            dbh => $res_dbh,
            db  => $db,
            %common_modules,
         );
      }

# Parse the CREATE TABLE defs from the POD.
      my @tables = get_save_results_tables(%common_modules);

# Empty the tables.  This is actually done via DROP TABLE IF EXISTS.
      if ( $o->get('empty-save-results-tables') ) {
         empty_save_results_tables(
            dbh  => $res_dbh,
            db   => $db,
            tbls => \@tables,
            %common_modules,
         );
      }

# Create the tables if necessary.  If they were dropped above, now
      # they'll be recreated.  If they never existed (e.g. new db), they'll
      # be recreated.  Or if they already exist, each def has "IF NOT EXISTS"
      # so existing tables will remain untouched.
      create_save_results_tables(
         dbh  => $res_dbh,
         db   => $db,
         tbls => \@tables,
         %common_modules,
      );

# Create views for the canned/example queries.
      # http://code.google.com/p/maatkit/issues/detail?id=1184
      if ( $o->get('create-views') ) {
         eval {
            create_views(
               dbh => $res_dbh,
               db  => $db,
               %common_modules,
            );
         };
         if ( $EVAL_ERROR ) {
            warn "Failed to create views: $EVAL_ERROR";
         }
      }
   }
   
   # ########################################################################
   # Do the version-check
   # ########################################################################
   if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
      VersionCheck::version_check(
         force     => $o->got('version-check'),
         instances => [
            { dbh => $dbh, dsn => $dsn },
            ($res_dbh ? { dbh => $res_dbh, dsn => $res_dsn } : ())
         ],
      );
   }

# ########################################################################
   # Populate the IndexUsage object with indexes.  Also get a list of all
   # databases and tables before going on to parse the queries.  This will be
   # important when we see a query without any default database, and we have to
   # guess which database to USE for EXPLAIN-ing it.  This code block doesn't
   # read query logs, it's just inventorying the tables and indexes.
   # ########################################################################

my $schema     = new Schema();
   my $schema_itr = new SchemaIterator(
      dbh          => $si_dbh,
      OptionParser => $o,
      Quoter       => $q,
      TableParser  => $tp,
      Schema       => $schema,
   );
   TALBE:
   while ( my $tbl = $schema_itr->next() ) {
      eval {
         my $ddl = $tbl->{ddl};
         if ( $ddl =~ m/CREATE (?:TEMPORARY )?TABLE "/ ) {
            $ddl = $tp->ansi_to_legacy($ddl);
         }
         my ($indexes) = $tp->get_keys($ddl, {});
         $iu->add_indexes(%$tbl, indexes=>$indexes);
      };
      if ( $EVAL_ERROR ) {
         warn $EVAL_ERROR unless $o->get('q');
         PTDEBUG && _d($EVAL_ERROR);
      }
   }
   $si_dbh->disconnect();

# ########################################################################
   # This keeps track of the $dbh's current DB, so we know when to USE a
   # different database.
   # ########################################################################
   my $cur_db = $o->get('database') || '';

# ########################################################################
   # This keeps track of statements that can't be EXPLAINed for some reason, so
   # they are not tried again.
   # ########################################################################
   my %err_for = ();

# ########################################################################
   # This is the main loop over the input filenames.
   # ########################################################################
   my $next_file = $fi->get_file_itr(@ARGV);
   my ( $fh, $filename, $filesize ) = $next_file->();
   FILE:
   while ( defined $fh ) {

# Create a callback to get events from the slow query log file.
      my $next_event = sub { return <$fh>; };
      my $tell = sub { return tell $fh; };
      my $event;
      my $get_event = sub {
         return $parser->parse_event(
            event      => $event,
            next_event => $next_event,
            tell       => $tell,
            oktorun    => sub { return 1 },
            misc       => {},
            stats      => {},
         );
      };

# #####################################################################
      # Set up a progress reporter.  For right now, we just do one per file.
      # Maybe someday we can do a global progress report?
      # #####################################################################
      my $pr;
      if ( $o->get('progress') && $filename && -e $filename ) {
         $pr = new Progress(
            jobsize => -s $filename,
            spec    => $o->get('progress'),
            name    => $filename,
         );
      }

# #####################################################################
      # This is the main loop over the queries in the log.  For each query we
      # are going to store what we learn about that query's EXPLAIN plan, keyed
      # off its fingerprint.
      # #####################################################################
      EVENT:
      while ( $event = $get_event->() ) {
         my $arg = $event->{arg} or next EVENT; # The arg is the SQL.
         my $fingerprint = $event->{fingerprint} = $qr->fingerprint($arg);

# Skip events that previously had an error.
         next if $err_for{$fingerprint};

eval {

# Checksum the query and get the query's ID.
            my $chk = make_checksum($arg);
            my $id  = make_checksum($fingerprint);

# Do we need to USE a new database before we EXPLAIN the query?
            my $new_db = $event->{db} || $event->{Schema};
            if ( $new_db && $new_db ne $cur_db ) {
               my $sql = 'USE ' . $q->quote($new_db);
               PTDEBUG && _d($sql);
               $dbh->do($sql);
               $cur_db = $new_db;
            }

# See if we've EXPLAINed this checksum before.  If so, just
            # increment counters with the saved info from $exa.  If not, EXPLAIN
            # and increment counters, then save to $exa.
            my $access = $exa->get_usage_for($chk, $cur_db);
            if ( !$access ) {

# The query might not be explain-able.  If that is so, it will
               # die, and we want that to happen so it gets blacklisted.  We
               # don't want it to return an error or something like that, and we
               # don't want to filter it out and skip it in the first place,
               # because then we will keep burning cycles on it trying to
               # explain it over and over.
               my $explain = $exa->explain_query(
                  dbh   => $dbh,
                  query => $arg,
               );
               $access = $exa->get_index_usage(
                  query   => $arg,
                  db      => $cur_db,
                  explain => $exa->normalize($explain),
               );
               $exa->save_usage_for($chk, $cur_db, $access);
               $iu->add_query(
                  query_id    => $id,
                  fingerprint => $fingerprint,
                  sample      => $arg,
               );
            }
            foreach my $row ( @$access ) {
               $iu->add_table_usage($row->{db}, $row->{tbl});
               $iu->add_index_usage(
                  usage    => $access,
                  query_id => $id,
               );
            }

};
         if ( $EVAL_ERROR ) {
            # Skip statements with this fingerprint in the future (blacklist).
            $err_for{$fingerprint} = { event => $event, error => $EVAL_ERROR };

# Log the error.
            PTDEBUG && _d('Problem on query', $event, $EVAL_ERROR);
            warn $EVAL_ERROR unless $o->get('q');
         }
         $pr->update($tell) if $pr;
      } # EVENT

( $fh, $filename, $filesize ) = $next_file->();
   } # FILE

# ########################################################################
   # All done!  Now print the reports, maybe.
   # ########################################################################
   if ( $res_dbh ) {
      $iu->save_results(
         dbh => $res_dbh,
         db  => $res_db,
      );
   }

if ( $o->get('report') ) {
      print_reports(
         dbh     => $dbh,
         err_for => \%err_for,
         %common_modules
      );
   }

$dbh->disconnect;
   $res_dbh->disconnect if $res_dbh;
   return 0;
} # End main().

# ############################################################################
# Subroutines.
# ############################################################################
sub print_reports {
   my ( %args ) = @_;
   my $iu      = $args{IndexUsage};
   my $o       = $args{OptionParser};
   my @reports = @{$o->get('report-format')};
   PTDEBUG && _d("Printing reports");

if ( grep { $_ eq 'drop_unused_indexes' } @reports ) {
      $iu->find_unused_indexes(
         sub {
            my ( $unused ) = @_;
            print_unused_indexes(
               unused => $unused,
               drop   => $o->get('drop'),
               %args,
            );
         }
      );
   }

return;
}

sub print_unused_indexes {
   my ( %args ) = @_;
   my @required_args = qw(unused drop Quoter);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($unused, $drop, $q) = @args{@required_args};

my $db_tbl = $q->quote($unused->{db}, $unused->{tbl});

# We must ignore the types that we're not dropping, then group
   # indexes of the remaining types together and print them together.
   my (@primary, @unique, @nonunique);
   foreach my $idx ( @{$unused->{idx}} ) {
      if ($idx->{name} =~ m/PRIMARY/i ) {
         push @primary, $idx;
      }
      elsif ( $idx->{is_unique} ) {
         push @unique, $idx;
      }
      else {
         push @nonunique, $idx;
      }
   }

print_alter_drop_key(
      db_tbl => $db_tbl,
      idx    => \@primary,
      type   => 'primary key',
      %args
   ) if $drop->{primary} || $drop->{all};

print_alter_drop_key(
      db_tbl => $db_tbl,
      idx    => \@unique,
      type   => 'unique',
      %args
   ) if $drop->{unique} || $drop->{all};

print_alter_drop_key(
      db_tbl => $db_tbl,
      idx    => \@nonunique,
      type   => 'non-unique',
      %args
   ) if $drop->{"non-unique"} || $drop->{all};

return;
}

sub print_alter_drop_key {
   my ( %args ) = @_;
   my @required_args = qw(db_tbl idx Quoter);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($db_tbl, $idx, $q) = @args{@required_args};

return unless @$idx;

print "\nALTER TABLE $db_tbl "
      . join(', ', map { "DROP KEY " . $q->quote($_->{name}) } @$idx)
      . ";"
      . ($args{type} ? " -- type:$args{type}" : "")
      . "\n";

return;
}

sub get_cxn {
   my ( %args ) = @_;
   my @required_args = qw(dsn OptionParser DSNParser);
   foreach my $arg ( @required_args ) {
      die "I need a $arg argument" unless $args{$arg};
   }
   my ($dsn, $o, $dp) = @args{@required_args};

if ( $o->get('ask-pass') ) {
      $dsn->{p} = OptionParser::prompt_noecho("Enter password "
         . ($args{for} ? "for $args{for}: " : ": "));
   }

my $dbh = $dp->get_dbh($dp->get_cxn_params($dsn), $args{opts});
   PTDEBUG && _d('Connected dbh', $dbh);
   return $dbh;
}

sub create_save_results_database {
   my ( %args ) = @_;
   my @required_args = qw(dbh db Quoter);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($dbh, $db, $q) = @args{@required_args};
   my $sql;

$db = $q->quote($db);

eval {
      PTDEBUG && _d("Checking if", $db, "database already exists");
      $sql = "USE $db";
      PTDEBUG && _d($dbh, $sql);
      $dbh->do($sql);
   };
   if ( $EVAL_ERROR ) {
      PTDEBUG && _d($db, "does not exist:", $EVAL_ERROR);
      $sql = "CREATE DATABASE $db";
      PTDEBUG && _d($dbh, $sql);
      $dbh->do($sql);

# Now USE the newly created db (the first attempt failed obviously).
      $sql = "USE $db";
      PTDEBUG && _d($dbh, $sql);
      $dbh->do($sql);
   }
   else {
      PTDEBUG && _d($db, "already exists");
   }

return;
}

sub get_save_results_tables {
   my ( %args ) = @_;
   my @required_args = qw(OptionParser);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($o)  = @args{@required_args};
   my $file = $args{file} || __FILE__;
   PTDEBUG && _d("Getting CREATE TABLE defs from POD");

my @table_defs = qw(indexes tables queries index_usage index_alternatives);
   my @tables;
   foreach my $tbl ( @table_defs ) {
      my $magic = "MAGIC_create_$tbl";
      my $sql   = $o->read_para_after($file, qr/$magic/);
      push @tables, {
         name => $tbl,
         def  => $sql,
      };
   }

return @tables;
}

sub empty_save_results_tables {
   my ( %args ) = @_;
   my @required_args = qw(dbh db tbls Quoter);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($dbh, $db, $tbls, $q) = @args{@required_args};

foreach my $tbl ( @$tbls ) {
      # Nothing is more "empty" than non-existence.  The tables
      # will be recreated later by calling create_save_results_tables().
      # Dropping and recreating has an advantage over truncating/deleting:
      # if the CREATE TABLE def is changed, this will auto-upgrade.
      my $sql = "DROP TABLE IF EXISTS " . $q->quote($db, $tbl->{name});
      PTDEBUG && _d($dbh, $sql);
      $dbh->do($sql);
   }

return;
}

sub create_save_results_tables {
   my ( %args ) = @_;
   my @required_args = qw(dbh db tbls);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($dbh, $db, $tbls) = @args{@required_args};

foreach my $tbl ( @$tbls ) {
      my $sql = $tbl->{def};
      PTDEBUG && _d($dbh, $sql);
      $dbh->do($sql);
   }

return;
}

sub create_views {
   my ( %args ) = @_;
   my @required_args = qw(dbh);
   foreach my $arg ( @required_args ) {
      die "I need a $arg arugment" unless $args{$arg};
   }
   my ($dbh) = @args{@required_args};
   PTDEBUG && _d("Creating views");

my $pod_parser = new PodParser();
   $pod_parser->parse_from_file(__FILE__);

my $magic = $pod_parser->get_magic('OPTIONS');
   foreach my $ident ( keys %$magic ) {
      next unless $ident =~ m/^view/;
      my $sql = "CREATE VIEW `$ident` AS $magic->{$ident}";
      PTDEBUG && _d($dbh, $sql);
      $dbh->do($sql);
   }

return;
}

# ############################################################################
# Run the program.
# ############################################################################
if ( !caller ) { exit main(@ARGV); }

1; # Because this is a module as well as a script.

# #############################################################################
# Documentation.
# #############################################################################

=pod

=head1 NAME

pt-index-usage - Read queries from a log and analyze how they use indexes.

=head1 SYNOPSIS

Usage: pt-index-usage [OPTIONS] [FILES]

pt-index-usage reads queries from logs and analyzes how they use indexes.

Analyze queries in slow.log and print reports:

pt-index-usage /path/to/slow.log --host localhost

Disable reports and save results to percona database for later analysis:

pt-index-usage slow.log --no-report --save-results-database percona

=head1 RISKS

Percona Toolkit is mature, proven in the real world, and well tested,
but all database tools can pose a risk to the system and the database
server.  Before using this tool, please:

=over

=item * Read the tool's documentation

=item * Review the tool's known L<"BUGS">

=item * Test the tool on a non-production server

=item * Backup your production server and verify the backups

=back

=head1 DESCRIPTION

This tool connects to a MySQL database server, reads through a query log, and
uses EXPLAIN to ask MySQL how it will use each query.  When it is finished, it
prints out a report on indexes that the queries didn't use.

The query log needs to be in MySQL's slow query log format.  If you need to
input a different format, you can use L<pt-query-digest> to translate the
formats.  If you don't specify a filename, the tool reads from STDIN.

The tool runs two stages.  In the first stage, the tool takes inventory of all
the tables and indexes in your database, so it can compare the existing indexes
to those that were actually used by the queries in the log.  In the second
stage, it runs EXPLAIN on each query in the query log.  It uses separate
database connections to inventory the tables and run EXPLAIN, so it opens two
connections to the database.

If a query is not a SELECT, it tries to transform it to a roughly equivalent
SELECT query so it can be EXPLAINed.  This is not a perfect process, but it is
good enough to be useful.

The tool skips the EXPLAIN step for queries that are exact duplicates of those
seen before.  It assumes that the same query will generate the same EXPLAIN plan
as it did previously (usually a safe assumption, and generally good for
performance), and simply increments the count of times that the indexes were
used.  However, queries that have the same fingerprint but different checksums
will be re-EXPLAINed.  Queries that have different literal constants can have
different execution plans, and this is important to measure.

After EXPLAIN-ing the query, it is necessary to try to map aliases in the query
back to the original table names.  For example, consider the EXPLAIN plan for
the following query:

SELECT * FROM tbl1 AS foo;

The EXPLAIN output will show access to table C<foo>, and that must be translated
back to C<tbl1>.  This process involves complex parsing.  It is generally very
accurate, but there is some chance that it might not work right.  If you find
cases where it fails, submit a bug report and a reproducible test case.

Queries that cannot be EXPLAINed will cause all subsequent queries with the
same fingerprint to be blacklisted.  This is to reduce the work they cause, and
prevent them from continuing to print error messages.  However, at least in
this stage of the tool's development, it is my opinion that it's not a good
idea to preemptively silence these, or prevent them from being EXPLAINed at
all.  I am looking for lots of feedback on how to improve things like the
query parsing.  So please submit your test cases based on the errors the tool
prints!

=head1 OUTPUT

After it reads all the events in the log, the tool prints out DROP statements
for every index that was not used.  It skips indexes for tables that were never
accessed by any queries in the log, to avoid false-positive results.

If you don't specify L<"--quiet">, the tool also outputs warnings about
statements that cannot be EXPLAINed and similar.  These go to standard error.

Progress reports are enabled by default (see L<"--progress">).  These also go to
standard error.

=head1 OPTIONS

This tool accepts additional command-line arguments.  Refer to the
L<"SYNOPSIS"> and usage information for details.

=over

=item --ask-pass

Prompt for a password when connecting to MySQL.

=item --charset

short form: -A; type: string

Default character set.  If the value is utf8, sets Perl's binmode on
STDOUT to utf8, passes the mysql_enable_utf8 option to DBD::mysql, and
runs SET NAMES UTF8 after connecting to MySQL.  Any other value sets
binmode on STDOUT without the utf8 layer, and runs SET NAMES after
connecting to MySQL.

=item --config

type: Array

Read this comma-separated list of config files; if specified, this must be the
first option on the command line.

=item --create-save-results-database

Create the L<"--save-results-database"> if it does not exist.

If the L<"--save-results-database"> already exists and this option is
specified, the database is used and the necessary tables are created if
they do not already exist.

=item --[no]create-views

Create views for L<"--save-results-database"> example queries.

Several example queries are given for querying the tables in the
L<"--save-results-database">.  These example queries are, by default, created
as views.  Specifying C<--no-create-views> prevents these views from being
created.

=item --database

short form: -D; type: string

The database to use for the connection.

=item --databases

short form: -d; type: hash

Only get tables and indexes from this comma-separated list of databases.

=item --databases-regex

type: string

Only get tables and indexes from database whose names match this Perl regex.

=item --defaults-file

short form: -F; type: string

Only read mysql options from the given file.  You must give an absolute pathname.

=item --drop

type: Hash; default: non-unique

Suggest dropping only these types of unused indexes.

By default pt-index-usage will only suggest to drop unused secondary indexes,
not primary or unique indexes.  You can specify which types of unused indexes
the tool suggests to drop: primary, unique, non-unique, all.

A separate C<ALTER TABLE> statement for each type is printed.  So if you
specify C<--drop all> and there is a primary key and a non-unique index,
the C<ALTER TABLE ... DROP> for each will be printed on separate lines.

=item --empty-save-results-tables

Drop and re-create all pre-existing tables in the L<"--save-results-database">.
This allows information from previous runs to be removed before the current run.

=item --help

Show help and exit.

=item --host

short form: -h; type: string

Connect to host.

=item --ignore-databases

type: Hash

Ignore this comma-separated list of databases.

=item --ignore-databases-regex

type: string

Ignore databases whose names match this Perl regex.

=item --ignore-tables

type: Hash

Ignore this comma-separated list of table names.

Table names may be qualified with the database name.

=item --ignore-tables-regex

type: string

Ignore tables whose names match the Perl regex.

=item --password

short form: -p; type: string

Password to use when connecting.
If password contains commas they must be escaped with a backslash: "exam\,ple"

=item --port

short form: -P; type: int

Port number to use for connection.

=item --progress

type: array; default: time,30

Print progress reports to STDERR.  The value is a comma-separated list with two
parts.  The first part can be percentage, time, or iterations; the second part
specifies how often an update should be printed, in percentage, seconds, or
number of iterations.

=item --quiet

short form: -q

Do not print any warnings.  Also disables L<"--progress">.

=item --[no]report

default: yes

Print the reports for L<"--report-format">.

You may want to disable the reports by specifying C<--no-report> if, for
example, you also specify L<"--save-results-database"> and you only want
to query the results tables later.

=item --report-format

type: Array; default: drop_unused_indexes

Right now there is only one report: drop_unused_indexes.  This report prints
SQL statements for dropping any unused indexes.  See also L<"--drop">.

See also L<"--[no]report">.

=item --save-results-database

type: DSN

Save results to tables in this database.  Information about indexes, queries,
tables and their usage is stored in several tables in the specified database.
The tables are auto-created if they do not exist.  If the database doesn't
exist, it can be auto-created with L<"--create-save-results-database">.  In this
case the connection is initially created with no default database, then after
the database is created, it is USE'ed.

pt-index-usage executes INSERT statements to save the results.  Therefore, you
should be careful if you use this feature on a production server.  It might
increase load, or cause trouble if you don't want the server to be written to,
or so on.

This is a new feature.  It may change in future releases.

After a run, you can query the usage tables to answer various questions about
index usage.  The tables have the following CREATE TABLE definitions:

MAGIC_create_indexes:

CREATE TABLE IF NOT EXISTS indexes (
    db           VARCHAR(64) NOT NULL,
    tbl          VARCHAR(64) NOT NULL,
    idx          VARCHAR(64) NOT NULL,
    cnt          BIGINT UNSIGNED NOT NULL DEFAULT 0,
    PRIMARY KEY  (db, tbl, idx)
  )

MAGIC_create_queries:

CREATE TABLE IF NOT EXISTS queries (
    query_id     BIGINT UNSIGNED NOT NULL,
    fingerprint  TEXT NOT NULL,
    sample       TEXT NOT NULL,
    PRIMARY KEY  (query_id)
  )

MAGIC_create_tables:

CREATE TABLE IF NOT EXISTS tables (
    db           VARCHAR(64) NOT NULL,
    tbl          VARCHAR(64) NOT NULL,
    cnt          BIGINT UNSIGNED NOT NULL DEFAULT 0,
    PRIMARY KEY  (db, tbl)
  )

MAGIC_create_index_usage:

CREATE TABLE IF NOT EXISTS index_usage (
    query_id      BIGINT UNSIGNED NOT NULL,
    db            VARCHAR(64) NOT NULL,
    tbl           VARCHAR(64) NOT NULL,
    idx           VARCHAR(64) NOT NULL,
    cnt           BIGINT UNSIGNED NOT NULL DEFAULT 1,
    UNIQUE INDEX  (query_id, db, tbl, idx)
  )

MAGIC_create_index_alternatives:

CREATE TABLE IF NOT EXISTS index_alternatives (
    query_id      BIGINT UNSIGNED NOT NULL, -- This query used
    db            VARCHAR(64) NOT NULL,     -- this index, but...
    tbl           VARCHAR(64) NOT NULL,     --
    idx           VARCHAR(64) NOT NULL,     --
    alt_idx       VARCHAR(64) NOT NULL,     -- was an alternative
    cnt           BIGINT UNSIGNED NOT NULL DEFAULT 1,
    UNIQUE INDEX  (query_id, db, tbl, idx, alt_idx),
    INDEX         (db, tbl, idx),
    INDEX         (db, tbl, alt_idx)
  )

The following are some queries you can run against these tables to answer common
questions you might have.  Each query is also created as a view (with MySQL
v5.0 and newer) if C<"--[no]create-views"> is true (it is by default).
The view names are the strings after the C<MAGIC_view_> prefix.

Question: which queries sometimes use different indexes, and what fraction of
the time is each index chosen?  MAGIC_view_query_uses_several_indexes:

SELECT iu.query_id, CONCAT_WS('.', iu.db, iu.tbl, iu.idx) AS idx,
    variations, iu.cnt, iu.cnt / total_cnt * 100 AS pct
 FROM index_usage AS iu
    INNER JOIN (
       SELECT query_id, db, tbl, SUM(cnt) AS total_cnt,
         COUNT(*) AS variations
       FROM index_usage
       GROUP BY query_id, db, tbl
       HAVING COUNT(*) > 1
    ) AS qv USING(query_id, db, tbl);

Question: which indexes have lots of alternatives, i.e. are chosen instead of
other indexes, and for what queries?  MAGIC_view_index_has_alternates:

SELECT CONCAT_WS('.', db, tbl, idx) AS idx_chosen,
    GROUP_CONCAT(DISTINCT alt_idx) AS alternatives,
    GROUP_CONCAT(DISTINCT query_id) AS queries, SUM(cnt) AS cnt
 FROM index_alternatives
 GROUP BY db, tbl, idx
 HAVING COUNT(*) > 1;

Question: which indexes are considered as alternates for other indexes, and for
what queries?  MAGIC_view_index_alternates:

SELECT CONCAT_WS('.', db, tbl, alt_idx) AS idx_considered,
    GROUP_CONCAT(DISTINCT idx) AS alternative_to,
    GROUP_CONCAT(DISTINCT query_id) AS queries, SUM(cnt) AS cnt
 FROM index_alternatives
 GROUP BY db, tbl, alt_idx
 HAVING COUNT(*) > 1;

Question: which of those are never chosen by any queries, and are therefore
superfluous?  MAGIC_view_unused_index_alternates:

SELECT CONCAT_WS('.', i.db, i.tbl, i.idx) AS idx,
    alt.alternative_to, alt.queries, alt.cnt
 FROM indexes AS i
    INNER JOIN (
       SELECT db, tbl, alt_idx, GROUP_CONCAT(DISTINCT idx) AS alternative_to,
          GROUP_CONCAT(DISTINCT query_id) AS queries, SUM(cnt) AS cnt
       FROM index_alternatives
       GROUP BY db, tbl, alt_idx
       HAVING COUNT(*) > 1
    ) AS alt ON i.db = alt.db AND i.tbl = alt.tbl
      AND i.idx = alt.alt_idx
 WHERE i.cnt = 0;

Question: given a table, which indexes were used, by how many queries, with how
many distinct fingerprints?  Were there alternatives?  Which indexes were not
used?  You can edit the following query's SELECT list to also see the query IDs
in question.  MAGIC_view_index_usage:

SELECT i.idx, iu.usage_cnt, iu.usage_total,
    ia.alt_cnt, ia.alt_total
 FROM indexes AS i
    LEFT OUTER JOIN (
       SELECT db, tbl, idx, COUNT(*) AS usage_cnt,
          SUM(cnt) AS usage_total, GROUP_CONCAT(query_id) AS used_by
       FROM index_usage
       GROUP BY db, tbl, idx
    ) AS iu ON i.db=iu.db AND i.tbl=iu.tbl AND i.idx = iu.idx
    LEFT OUTER JOIN (
       SELECT db, tbl, idx, COUNT(*) AS alt_cnt,
          SUM(cnt) AS alt_total,
          GROUP_CONCAT(query_id) AS alt_queries
       FROM index_alternatives
       GROUP BY db, tbl, idx
    ) AS ia ON i.db=ia.db AND i.tbl=ia.tbl AND i.idx = ia.idx;

Question: which indexes on a given table are vital for at least one query (there
is no alternative)?  MAGIC_view_required_indexes:

SELECT i.db, i.tbl, i.idx, no_alt.queries
   FROM indexes AS i
      INNER JOIN (
         SELECT iu.db, iu.tbl, iu.idx,
            GROUP_CONCAT(iu.query_id) AS queries
         FROM index_usage AS iu
            LEFT OUTER JOIN index_alternatives AS ia
               USING(db, tbl, idx)
         WHERE ia.db IS NULL
         GROUP BY iu.db, iu.tbl, iu.idx
      ) AS no_alt ON no_alt.db = i.db AND no_alt.tbl = i.tbl
         AND no_alt.idx = i.idx
   ORDER BY i.db, i.tbl, i.idx, no_alt.queries;

=item --set-vars

type: Array

Set the MySQL variables in this comma-separated list of C<variable=value> pairs.

By default, the tool sets:

=for comment ignore-pt-internal-value
MAGIC_set_vars

wait_timeout=10000

Variables specified on the command line override these defaults.  For
example, specifying C<--set-vars wait_timeout=500> overrides the defaultvalue of C<10000>.

The tool prints a warning and continues if a variable cannot be set.

=item --socket

short form: -S; type: string

Socket file to use for connection.

=item --tables

short form: -t; type: hash

Only get indexes from this comma-separated list of tables.

=item --tables-regex

type: string

Only get indexes from tables whose names match this Perl regex.

=item --user

short form: -u; type: string

User for login if not current user.

=item --version

Show version and exit.

=item --[no]version-check

default: yes

Check for the latest version of Percona Toolkit, MySQL, and other programs.

This is a standard "check for updates automatically" feature, with two
additional features.  First, the tool checks the version of other programs
on the local system in addition to its own version.  For example, it checks
the version of every MySQL server it connects to, Perl, and the Perl module
DBD::mysql.  Second, it checks for and warns about versions with known
problems.  For example, MySQL 5.5.25 had a critical bug and was re-released
as 5.5.25a.

Any updates or known problems are printed to STDOUT before the tool's normal
output.  This feature should never interfere with the normal operation of the
tool.

For more information, visit L<https://www.percona.com/version-check>.

=back

=head1 DSN OPTIONS

These DSN options are used to create a DSN.  Each option is given like
C<option=value>.  The options are case-sensitive, so P and p are not the
same option.  There cannot be whitespace before or after the C<=> and
if the value contains whitespace it must be quoted.  DSN options are
comma-separated.  See the L<percona-toolkit> manpage for full details.

=over

=item * A

dsn: charset; copy: yes

Default character set.

=item * D

dsn: database; copy: yes

Database to connect to.

=item * F

dsn: mysql_read_default_file; copy: yes

Only read default options from the given file

=item * h

dsn: host; copy: yes

Connect to host.

=item * p

dsn: password; copy: yes

Password to use when connecting.
If password contains commas they must be escaped with a backslash: "exam\,ple"

=item * P

dsn: port; copy: yes

Port number to use for connection.

=item * S

dsn: mysql_socket; copy: yes

Socket file to use for connection.

=item * u

dsn: user; copy: yes

User for login if not current user.

=back

=head1 ENVIRONMENT

The environment variable C<PTDEBUG> enables verbose debugging output to STDERR.
To enable debugging and capture all output to a file, run the tool like:

PTDEBUG=1 pt-index-usage ... > FILE 2>&1

Be careful: debugging output is voluminous and can generate several megabytes
of output.

=head1 SYSTEM REQUIREMENTS

You need Perl, DBI, DBD::mysql, and some core packages that ought to be
installed in any reasonably new version of Perl.

=head1 BUGS

For a list of known bugs, see L<http://www.percona.com/bugs/pt-index-usage>.

Please report bugs at L<https://bugs.launchpad.net/percona-toolkit>.
Include the following information in your bug report:

=over

=item * Complete command-line used to run the tool

=item * Tool L<"--version">

=item * MySQL version of all servers involved

=item * Output from the tool including STDERR

=item * Input files (log/dump/config files, etc.)

=back

If possible, include debugging output by running the tool with C<PTDEBUG>;
see L<"ENVIRONMENT">.

=head1 DOWNLOADING

Visit L<http://www.percona.com/software/percona-toolkit/> to download the
latest release of Percona Toolkit.  Or, get the latest release from the
command line:

wget percona.com/get/percona-toolkit.tar.gz

wget percona.com/get/percona-toolkit.rpm

wget percona.com/get/percona-toolkit.deb

You can also get individual tools from the latest release:

wget percona.com/get/TOOL

Replace C<TOOL> with the name of any tool.

=head1 AUTHORS

Baron Schwartz and Daniel Nichter

=head1 ABOUT PERCONA TOOLKIT

This tool is part of Percona Toolkit, a collection of advanced command-line
tools for MySQL developed by Percona.  Percona Toolkit was forked from two
projects in June, 2011: Maatkit and Aspersa.  Those projects were created by
Baron Schwartz and primarily developed by him and Daniel Nichter.  Visit
L<http://www.percona.com/software/> to learn about other free, open-source
software from Percona.

=head1 COPYRIGHT, LICENSE, AND WARRANTY

This program is copyright 2011-2015 Percona LLC and/or its affiliates,
2010-2011 Baron Schwartz.

THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

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, version 2; OR the Perl Artistic License.  On UNIX and similar
systems, you can issue `man perlgpl' or `man perlartistic' to read these
licenses.

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.

=head1 VERSION

pt-index-usage 2.2.16

=cut

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	dr-xr-xr-x	2025-06-13 09:16:50
..	dir	-	root/root	drwxr-xr-x	2025-04-17 05:01:22
7z	text/x-shellscript	45 B	root/root	-rwxr-xr-x	2024-10-04 01:50:29
7za	text/x-shellscript	46 B	root/root	-rwxr-xr-x	2024-10-04 01:50:29
GET	text/x-perl	15.84 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
HEAD	text/x-perl	15.84 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
Magick-config	text/x-shellscript	1.43 KB	root/root	-rwxr-xr-x	2025-04-01 01:10:59
MagickCore-config	text/x-shellscript	1.56 KB	root/root	-rwxr-xr-x	2025-04-01 01:10:59
MagickWand-config	text/x-shellscript	1.56 KB	root/root	-rwxr-xr-x	2025-04-01 01:10:59
Mail	application/x-pie-executable	408.89 KB	root/root	-rwxr-xr-x	2019-10-13 12:19:50
POST	text/x-perl	15.84 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
Wand-config	text/x-shellscript	1.42 KB	root/root	-rwxr-xr-x	2025-04-01 01:10:59
[	application/x-pie-executable	53.67 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
ac	application/x-pie-executable	33.07 KB	root/root	-rwxr-xr-x	2019-10-21 04:09:19
aclocal	text/x-perl	35.62 KB	root/root	-rwxr-xr-x	2023-10-14 08:00:43
aclocal-1.16	text/x-perl	35.62 KB	root/root	-rwxr-xr-x	2023-10-14 08:00:43
acyclic	application/x-pie-executable	12.41 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
addr2line	application/x-pie-executable	33.41 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
agentxtrap	application/x-pie-executable	24.53 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
alias	text/x-shellscript	29 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
altermime	application/x-executable	119.04 KB	root/root	-rwxr-xr-x	2019-08-26 06:25:27
amavisd-agent	text/x-perl	13.15 KB	root/root	-rwxr-xr-x	2024-03-14 02:29:57
amavisd-nanny	text/x-perl	11.75 KB	root/root	-rwxr-xr-x	2024-03-14 02:29:57
amavisd-release	text/x-perl	12.39 KB	root/root	-rwxr-xr-x	2024-03-14 02:29:57
amavisd-signer	text/x-perl	37.03 KB	root/root	-rwxr-xr-x	2024-03-14 02:29:57
amavisd-submit	text/x-perl	9.13 KB	root/root	-rwxr-xr-x	2024-03-14 02:29:57
animate	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
apr-1-config	text/x-shellscript	6.76 KB	root/root	-rwxr-xr-x	2017-10-14 08:21:19
apropos	application/x-pie-executable	54.04 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
apu-1-config	text/x-shellscript	5.97 KB	root/root	-rwxr-xr-x	2017-10-14 08:33:07
ar	application/x-pie-executable	61.96 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
arch	application/x-pie-executable	37.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
aria_chk	application/x-pie-executable	4.53 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
aria_dump_log	application/x-pie-executable	4.33 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
aria_ftdump	application/x-pie-executable	4.34 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
aria_pack	application/x-pie-executable	4.37 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
aria_read_log	application/x-pie-executable	4.49 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
arj	application/x-pie-executable	236.77 KB	root/root	-rwxr-xr-x	2019-07-23 09:41:48
arjdisp	application/x-pie-executable	20.94 KB	root/root	-rwxr-xr-x	2019-07-23 09:41:48
arpaname	application/x-pie-executable	11.82 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
as	application/x-pie-executable	889.91 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
aspell	application/x-pie-executable	159.5 KB	root/root	-rwxr-xr-x	2022-04-18 03:10:53
at	application/x-pie-executable	57.33 KB	root/root	-rwsr-xr-x	2022-10-10 10:23:17
atq	application/x-pie-executable	57.33 KB	root/root	-rwsr-xr-x	2022-10-10 10:23:17
atrm	application/x-pie-executable	57.33 KB	root/root	-rwsr-xr-x	2022-10-10 10:23:17
attr	application/x-pie-executable	13.06 KB	root/root	-rwxr-xr-x	2019-10-11 05:58:09
authselect	application/x-pie-executable	41.13 KB	root/root	-rwxr-xr-x	2023-10-14 06:06:30
autoconf	text/x-shellscript	14.42 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
autoheader	text/x-perl	8.33 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
autom4te	text/x-perl	31.43 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
automake	text/x-perl	251.9 KB	root/root	-rwxr-xr-x	2023-10-14 08:00:43
automake-1.16	text/x-perl	251.9 KB	root/root	-rwxr-xr-x	2023-10-14 08:00:43
autoreconf	text/x-perl	20.57 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
autoscan	text/x-perl	16.72 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
autoupdate	text/x-perl	33.08 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
awk	application/x-pie-executable	669.77 KB	root/root	-rwxr-xr-x	2022-04-18 03:56:05
b2sum	application/x-pie-executable	57.76 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
backup		23.48 KB	root/root	-rwx------	2025-06-10 09:26:18
baksync		20.22 KB	root/root	-rwx------	2025-06-10 09:26:18
base32	application/x-pie-executable	41.55 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
base64	application/x-pie-executable	41.56 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
basename	application/x-pie-executable	37.49 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
bash	application/x-pie-executable	1.1 MB	root/root	-rwxr-xr-x	2024-05-23 08:55:42
bashbug	text/x-shellscript	7.18 KB	root/root	-rwxr-xr-x	2024-05-23 08:55:35
bashbug-64	text/x-shellscript	7.18 KB	root/root	-rwxr-xr-x	2024-05-23 08:55:35
batch	text/x-shellscript	137 B	root/root	-rwxr-xr-x	2022-10-10 10:23:17
bc	application/x-pie-executable	94.98 KB	root/root	-rwxr-xr-x	2019-10-12 12:34:38
bcomps	application/x-pie-executable	20.62 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
bdftopcf	application/x-pie-executable	45.4 KB	root/root	-rwxr-xr-x	2021-10-09 11:42:47
bg	text/x-shellscript	26 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
binhex.pl	text/x-perl	3.74 KB	root/root	-rwxr-xr-x	2019-08-27 02:35:28
bison	application/x-pie-executable	437.72 KB	root/root	-rwxr-xr-x	2019-10-12 12:28:39
bootctl	application/x-pie-executable	45.15 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:56
brotli	application/x-pie-executable	739.2 KB	root/root	-rwxr-xr-x	2021-04-08 09:00:44
bunzip2	application/x-pie-executable	36.86 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:59
busctl	application/x-pie-executable	77.26 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:56
bzcat	application/x-pie-executable	36.86 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:59
bzcmp	text/x-shellscript	2.08 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
bzdiff	text/x-shellscript	2.08 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
bzegrep	text/x-shellscript	1.64 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
bzfgrep	text/x-shellscript	1.64 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
bzgrep	text/x-shellscript	1.64 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
bzip2	application/x-pie-executable	36.86 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:59
bzip2recover	application/x-pie-executable	16.44 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:59
bzless	text/x-shellscript	1.23 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
bzmore	text/x-shellscript	1.23 KB	root/root	-rwxr-xr-x	2025-01-28 01:38:58
c++	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:33
c++filt	application/x-pie-executable	28.89 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
c89	text/x-shellscript	224 B	root/root	-rwxr-xr-x	2025-03-31 10:36:31
c99	text/x-shellscript	215 B	root/root	-rwxr-xr-x	2025-03-31 10:36:31
ca-legacy	text/x-shellscript	1.61 KB	root/root	-rwxr-xr-x	2024-08-21 07:16:41
cabextract	application/x-pie-executable	69.95 KB	root/root	-rwxr-xr-x	2025-03-06 01:18:17
cairo-sphinx	application/x-pie-executable	69.71 KB	root/root	-rwxr-xr-x	2022-04-18 04:06:31
cal	application/x-pie-executable	65.98 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
captoinfo	application/x-pie-executable	85.31 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
cat	application/x-pie-executable	37.54 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
catchsegv	text/x-shellscript	3.21 KB	root/root	-rwxr-xr-x	2025-06-09 08:25:38
catman	application/x-pie-executable	41.45 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
cc	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
ccmake	application/x-pie-executable	8.38 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:57
ccmake3	application/x-pie-executable	8.38 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:57
ccomps	application/x-pie-executable	24.72 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
cd	text/x-shellscript	26 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
chacl	application/x-pie-executable	16.36 KB	root/root	-rwxr-xr-x	2024-04-06 12:15:42
chage	application/x-pie-executable	77.68 KB	root/root	-rwsr-xr-x	2024-04-06 02:00:13
chardetect	text/plain	400 B	root/root	-rwxr-xr-x	2019-10-12 07:18:01
chattr	application/x-pie-executable	16.41 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:19
chcon	application/x-pie-executable	70.43 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
chfn		32.89 KB	root/root	-rws--x--x	2024-04-06 01:02:53
chgrp	application/x-pie-executable	66.35 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
chmem	application/x-pie-executable	45.47 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
chmod	application/x-pie-executable	62.29 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
chown	application/x-pie-executable	70.39 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
chrt	application/x-pie-executable	37.18 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
chsh		24.71 KB	root/root	-rws--x--x	2024-04-06 01:02:53
chvt	application/x-pie-executable	12.53 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
cifsdd	application/x-pie-executable	85.98 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
cifsiostat	application/x-pie-executable	41.35 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
circo	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
cksum	application/x-pie-executable	37.46 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
clambc	application/x-pie-executable	140.97 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
clamconf	application/x-pie-executable	140.94 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
clamdscan	application/x-pie-executable	157.31 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
clamdtop	application/x-pie-executable	157.3 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
clamscan	application/x-pie-executable	173.19 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
clamsubmit	application/x-pie-executable	153.27 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
clear	application/x-pie-executable	12.54 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
cluster	application/x-pie-executable	518.33 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
cmake	application/x-pie-executable	8.68 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:56
cmake3	application/x-pie-executable	8.68 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:56
cmp	application/x-pie-executable	103.76 KB	root/root	-rwxr-xr-x	2020-05-04 03:15:14
col	application/x-pie-executable	29 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
colcrt	application/x-pie-executable	16.48 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
colrm	application/x-pie-executable	24.88 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
column	application/x-pie-executable	49.47 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
comm	application/x-pie-executable	41.63 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
command	text/x-shellscript	31 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
compare	application/x-pie-executable	11.85 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
compile_et	text/x-shellscript	1.31 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:08
composite	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
compress	application/x-pie-executable	25.37 KB	root/root	-rwxr-xr-x	2020-08-30 05:37:33
config_data	text/x-perl	6.97 KB	root/root	-rwxr-xr-x	2019-10-13 10:59:01
conjure	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
consolehelper	application/x-pie-executable	11.88 KB	root/root	-rwxr-xr-x	2021-10-08 07:29:24
convert	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
coredumpctl	application/x-pie-executable	44.91 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
corelist	text/x-perl	14.64 KB	root/root	-rwxr-xr-x	2019-10-13 11:00:26
cp	application/x-pie-executable	148.05 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
cpack	application/x-pie-executable	8.87 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:58
cpack3	application/x-pie-executable	8.87 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:58
cpan	text/x-perl	8.17 KB	root/root	-rwxr-xr-x	2025-06-03 02:32:21
cpan-mirrors	text/x-perl	4.19 KB	root/root	-rwxr-xr-x	2025-06-03 02:32:21
cpp	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:33
crb	text/x-shellscript	2.58 KB	root/root	-rwxr--r--	2025-04-22 05:22:20
crc32	text/x-perl	1.02 KB	root/root	-rwxr-xr-x	2019-11-12 06:41:42
cronnext	application/x-pie-executable	49.8 KB	root/root	-rwxr-xr-x	2024-04-06 11:40:05
crontab	application/x-pie-executable	61.67 KB	root/root	-rwsr-xr-x	2024-04-06 11:40:05
csh	application/x-pie-executable	432.09 KB	root/root	-rwxr-xr-x	2022-04-18 05:03:39
csplit	application/x-pie-executable	53.76 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
csslint-0.6	application/x-pie-executable	24.56 KB	root/root	-rwxr-xr-x	2020-09-22 09:07:00
ctest	application/x-pie-executable	9.9 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:58
ctest3	application/x-pie-executable	9.9 MB	root/root	-rwxr-xr-x	2024-04-05 08:03:58
curl	application/x-pie-executable	230.09 KB	root/root	-rwxr-xr-x	2025-01-28 01:43:10
curl-config	text/x-shellscript	4.47 KB	root/root	-rwxr-xr-x	2025-01-28 01:42:58
curve_keygen	application/x-pie-executable	11.88 KB	root/root	-rwxr-xr-x	2023-03-08 09:40:38
cut	application/x-pie-executable	49.59 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
cvtsudoers	application/x-pie-executable	284.13 KB	root/root	-rwxr-xr-x	2024-02-14 02:13:50
cxpm	application/x-pie-executable	29.11 KB	root/root	-rwxr-xr-x	2024-03-30 01:53:16
date	application/x-pie-executable	106.03 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
db_archive	application/x-pie-executable	12.45 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_checkpoint	application/x-pie-executable	16.48 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_deadlock	application/x-pie-executable	16.48 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_dump	application/x-pie-executable	16.51 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_dump185	application/x-pie-executable	69.55 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_hotbackup	application/x-pie-executable	20.49 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_load	application/x-pie-executable	28.61 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_log_verify	application/x-pie-executable	16.52 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_printlog	application/x-pie-executable	33.4 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_recover	application/x-pie-executable	16.51 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_replicate	application/x-pie-executable	16.49 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_stat	application/x-pie-executable	16.48 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_tuner	application/x-pie-executable	24.55 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_upgrade	application/x-pie-executable	12.45 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
db_verify	application/x-pie-executable	16.46 KB	root/root	-rwxr-xr-x	2021-09-21 04:38:10
dbilogstrip	text/x-perl	1.35 KB	root/root	-rwxr-xr-x	2022-04-25 04:10:04
dbinfo	text/x-perl	4.5 KB	root/root	-rwxr-xr-x	2019-08-29 02:25:58
dbiprof	text/x-perl	6.06 KB	root/root	-rwxr-xr-x	2022-04-25 04:10:04
dbus-binding-tool	application/x-pie-executable	110.43 KB	root/root	-rwxr-xr-x	2019-10-25 12:53:05
dbus-cleanup-sockets	application/x-pie-executable	16.38 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-daemon	application/x-pie-executable	239.76 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-monitor	application/x-pie-executable	28.63 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-run-session	application/x-pie-executable	15.95 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-send	application/x-pie-executable	28.6 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-test-tool	application/x-pie-executable	24.66 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-update-activation-environment	application/x-pie-executable	16.47 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbus-uuidgen	application/x-pie-executable	12.37 KB	root/root	-rwxr-xr-x	2023-10-15 06:29:16
dbwrap_tool	application/x-pie-executable	28.84 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
dc	application/x-pie-executable	53.02 KB	root/root	-rwxr-xr-x	2019-10-12 12:34:38
dd	application/x-pie-executable	78.05 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
deallocvt	application/x-pie-executable	12.54 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
debinhex.pl	text/x-perl	5.66 KB	root/root	-rwxr-xr-x	2019-08-27 02:35:28
debuginfod-find	application/x-pie-executable	16.47 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
delv	application/x-pie-executable	42.46 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
derb	application/x-pie-executable	39.43 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:34
df	application/x-pie-executable	91.16 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
diff	application/x-pie-executable	268.01 KB	root/root	-rwxr-xr-x	2020-05-04 03:15:14
diff3	application/x-pie-executable	128.6 KB	root/root	-rwxr-xr-x	2020-05-04 03:15:14
diffimg	application/x-pie-executable	12.27 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
dig	application/x-pie-executable	162.19 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
dijkstra	application/x-pie-executable	16.71 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
dir	application/x-pie-executable	139.97 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
dircolors	application/x-pie-executable	49.63 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
dirmngr	application/x-pie-executable	580.16 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
dirmngr-client	application/x-pie-executable	120.12 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
dirname	application/x-pie-executable	33.44 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
display	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
dm_date	text/x-perl	5.38 KB	root/root	-rwxr-xr-x	2023-10-14 05:00:44
dm_zdump	text/x-perl	4.99 KB	root/root	-rwxr-xr-x	2023-10-14 05:00:44
dmesg	application/x-pie-executable	77.88 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
dnf	text/x-script.python	2.05 KB	root/root	-rwxr-xr-x	2025-03-11 09:47:56
dnf-3	text/x-script.python	2.05 KB	root/root	-rwxr-xr-x	2025-03-11 09:47:56
dnsdomainname	application/x-pie-executable	21.16 KB	root/root	-rwxr-xr-x	2019-10-11 01:06:51
dnstap-read	application/x-pie-executable	20.43 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
domainname	application/x-pie-executable	21.16 KB	root/root	-rwxr-xr-x	2019-10-11 01:06:51
dot	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
dot2gxl	application/x-pie-executable	41.3 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
dotty	text/x-shellscript	2.04 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:07
doveadm	application/x-pie-executable	678.1 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
doveconf	application/x-pie-executable	185.02 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
dovecot-sysreport	text/x-shellscript	5.63 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:19
dsync	application/x-pie-executable	678.1 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
dtrace	text/x-script.python	17.39 KB	root/root	-rwxr-xr-x	2023-10-14 01:06:45
du	application/x-pie-executable	107.1 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
dumpkeys	application/x-pie-executable	169.88 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
dumpmscat	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
dumpsexp	application/x-pie-executable	16.43 KB	root/root	-rwxr-xr-x	2022-06-28 11:54:07
dwp	application/x-pie-executable	2.13 MB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
dwz	application/x-pie-executable	167.64 KB	root/root	-rwxr-xr-x	2021-10-09 03:26:08
easy_install-3	text/plain	246 B	root/root	-rwxr-xr-x	2024-08-19 07:28:57
easy_install-3.6	text/plain	246 B	root/root	-rwxr-xr-x	2024-08-19 07:28:57
easy_install-3.8	text/x-script.python	232 B	root/root	-rwxr-xr-x	2022-04-21 12:45:23
echo	application/x-pie-executable	37.43 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
ed	application/x-pie-executable	57.28 KB	root/root	-rwxr-xr-x	2019-10-11 01:05:15
edgepaint	application/x-pie-executable	420.79 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
egrep	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2019-10-11 03:15:56
eject	application/x-pie-executable	57.78 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
elfedit	application/x-pie-executable	33.3 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
elinks	application/x-pie-executable	1.55 MB	root/root	-rwxr-xr-x	2019-10-14 07:31:15
enc2xs	text/x-perl	40.97 KB	root/root	-rwxr-xr-x	2019-10-13 08:46:10
encguess	text/x-perl	2.91 KB	root/root	-rwxr-xr-x	2019-10-13 08:46:10
enchant	application/x-pie-executable	21.08 KB	root/root	-rwxr-xr-x	2019-10-23 08:03:55
enchant-lsmod	application/x-pie-executable	13.09 KB	root/root	-rwxr-xr-x	2019-10-23 08:03:55
encode_keychange	application/x-pie-executable	24.45 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
env	application/x-pie-executable	41.43 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
eqn	application/x-pie-executable	232.16 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
eu-addr2line	application/x-pie-executable	28.48 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-ar	application/x-pie-executable	40.89 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-elfclassify	application/x-pie-executable	26.41 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-elfcmp	application/x-pie-executable	348.73 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-elfcompress	application/x-pie-executable	32.95 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-elflint	application/x-pie-executable	429.23 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-findtextrel	application/x-pie-executable	20.66 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-make-debug-archive	text/x-shellscript	2.84 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:44
eu-nm	application/x-pie-executable	361.16 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-objdump	application/x-pie-executable	349.01 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-ranlib	application/x-pie-executable	24.61 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-readelf	application/x-pie-executable	574.1 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-size	application/x-pie-executable	20.51 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-srcfiles	application/x-pie-executable	25.07 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-stack	application/x-pie-executable	29.4 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-strings	application/x-pie-executable	24.57 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-strip	application/x-pie-executable	369.01 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
eu-unstrip	application/x-pie-executable	52.89 KB	root/root	-rwxr-xr-x	2024-04-06 01:39:58
evmctl	application/x-pie-executable	62.54 KB	root/root	-rwxr-xr-x	2021-04-08 03:44:17
ex	application/x-pie-executable	1.13 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
expand	application/x-pie-executable	41.66 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
expr	application/x-pie-executable	49.65 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
factor	application/x-pie-executable	86.05 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
fallocate	application/x-pie-executable	28.96 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
false	application/x-pie-executable	33.39 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
fc	text/x-shellscript	26 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
fc-cache	text/x-shellscript	132 B	root/root	-rwxr-xr-x	2021-08-16 11:04:22
fc-cache-64	application/x-pie-executable	20.35 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-cat	application/x-pie-executable	16.35 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-conflist	application/x-pie-executable	12.25 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-list	application/x-pie-executable	12.25 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-match	application/x-pie-executable	16.26 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-pattern	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-query	application/x-pie-executable	12.24 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-scan	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fc-validate	application/x-pie-executable	16.26 KB	root/root	-rwxr-xr-x	2021-10-09 09:02:09
fcat	application/x-pie-executable	32.39 KB	root/root	-rwxr-xr-x	2019-07-23 09:19:31
fdp	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
fetchmail	application/x-pie-executable	313.01 KB	root/root	-rwxr-xr-x	2022-04-18 03:28:00
fg	text/x-shellscript	26 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
fgconsole	application/x-pie-executable	12.55 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
fgrep	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2019-10-11 03:15:56
filan	application/x-pie-executable	94.78 KB	root/root	-rwxr-xr-x	2021-10-08 03:43:20
file	application/x-pie-executable	24.68 KB	root/root	-rwxr-xr-x	2024-04-06 02:44:54
fincore	application/x-pie-executable	33.03 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
find	application/x-pie-executable	223.3 KB	root/root	-rwxr-xr-x	2024-09-24 02:19:34
findmnt	application/x-pie-executable	70.6 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
fixperms	text/plain	210 B	root/root	-rwxr-xr-x	2024-01-19 02:31:30
flex	application/x-pie-executable	428.45 KB	root/root	-rwxr-xr-x	2019-10-12 12:33:17
flex++	application/x-pie-executable	428.45 KB	root/root	-rwxr-xr-x	2019-10-12 12:33:17
flock	application/x-pie-executable	33.2 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
fmt	application/x-pie-executable	45.57 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
fold	application/x-pie-executable	41.48 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
fonttosfnt	application/x-pie-executable	41.18 KB	root/root	-rwxr-xr-x	2021-10-09 11:42:47
formail	application/x-pie-executable	48.22 KB	root/root	-rwxr-xr-x	2019-10-12 11:30:08
fpmstatus	text/plain	981 B	root/root	-rwxr-xr-x	2024-02-16 04:53:21
free	application/x-pie-executable	20.79 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
freetype-config	text/x-shellscript	4.31 KB	root/root	-rwxr-xr-x	2025-03-31 07:37:30
freeze	application/x-pie-executable	32.39 KB	root/root	-rwxr-xr-x	2019-07-23 09:19:31
freshclam	application/x-pie-executable	56.93 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
fribidi	application/x-pie-executable	21.14 KB	root/root	-rwxr-xr-x	2022-10-08 11:16:47
ftp	application/x-pie-executable	101.2 KB	root/root	-rwxr-xr-x	2019-10-12 12:59:55
funzip	application/x-pie-executable	36.63 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:12
g++	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:33
g13	application/x-pie-executable	212.02 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
galera_new_cluster	text/x-shellscript	917 B	root/root	-rwxr-xr-x	2025-04-27 06:16:05
galera_recovery	text/x-shellscript	3.29 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
gapplication	application/x-pie-executable	20.45 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
garb-systemd	text/x-shellscript	1.2 KB	root/root	-rwxr-xr-x	2025-04-01 02:29:30
garbd	application/x-executable	2.31 MB	root/root	-rwxr-xr-x	2025-04-01 02:29:30
gawk	application/x-pie-executable	669.77 KB	root/root	-rwxr-xr-x	2022-04-18 03:56:05
gc	application/x-pie-executable	16.64 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
gcc	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
gcc-ar	application/x-pie-executable	36.66 KB	root/root	-rwxr-xr-x	2025-03-31 10:38:33
gcc-nm	application/x-pie-executable	36.66 KB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
gcc-ranlib	application/x-pie-executable	36.66 KB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
gcore	text/x-shellscript	3.35 KB	root/root	-rwxr-xr-x	2023-10-11 07:09:51
gcov	application/x-pie-executable	1.31 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
gcov-dump	application/x-pie-executable	570.88 KB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
gcov-tool	application/x-pie-executable	607.75 KB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
gdb	application/x-pie-executable	10.99 MB	root/root	-rwxr-xr-x	2023-10-11 07:10:11
gdb-add-index	text/x-shellscript	3.28 KB	root/root	-rwxr-xr-x	2023-10-11 07:09:51
gdbm_dump	application/x-pie-executable	21.05 KB	root/root	-rwxr-xr-x	2022-10-08 01:22:08
gdbm_load	application/x-pie-executable	25.31 KB	root/root	-rwxr-xr-x	2022-10-08 01:22:08
gdbmtool	application/x-pie-executable	111.57 KB	root/root	-rwxr-xr-x	2022-10-08 01:22:08
gdbus	application/x-pie-executable	48.71 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
gdbus-codegen	text/x-script.python	2 KB	root/root	-rwxr-xr-x	2024-11-05 02:02:47
gdk-pixbuf-query-loaders-64	application/x-pie-executable	15.93 KB	root/root	-rwxr-xr-x	2024-05-24 04:59:47
gdk-pixbuf-thumbnailer	application/x-pie-executable	20.44 KB	root/root	-rwxr-xr-x	2024-05-24 04:59:47
genbrk	application/x-pie-executable	22.11 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
gencat	application/x-pie-executable	24.84 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
gencfu	application/x-pie-executable	22.02 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
gencnval	application/x-pie-executable	30.39 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
gendict	application/x-pie-executable	35.77 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
genrb	application/x-pie-executable	175.27 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
geoiplookup	application/x-pie-executable	21.89 KB	root/root	-rwxr-xr-x	2019-11-28 10:06:01
geoiplookup6	application/x-pie-executable	21.65 KB	root/root	-rwxr-xr-x	2019-11-28 10:06:01
geqn	application/x-pie-executable	232.16 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
getconf	application/x-pie-executable	32.46 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
getent	application/x-pie-executable	33.13 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
getfacl	application/x-pie-executable	25.38 KB	root/root	-rwxr-xr-x	2024-04-06 12:15:42
getfattr	application/x-pie-executable	23.03 KB	root/root	-rwxr-xr-x	2019-10-11 05:58:09
getkeycodes	application/x-pie-executable	12.54 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
getopt	application/x-pie-executable	20.52 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
getopts	text/x-shellscript	31 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
gio	application/x-pie-executable	85.21 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
gio-querymodules-64	application/x-pie-executable	16.3 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
git	application/x-pie-executable	3.67 MB	root/root	-rwxr-xr-x	2025-06-03 03:16:16
git-receive-pack	application/x-pie-executable	3.67 MB	root/root	-rwxr-xr-x	2025-06-03 03:16:16
git-shell	application/x-pie-executable	2.13 MB	root/root	-rwxr-xr-x	2025-06-03 03:16:16
git-upload-archive	application/x-pie-executable	3.67 MB	root/root	-rwxr-xr-x	2025-06-03 03:16:16
git-upload-pack	application/x-pie-executable	3.67 MB	root/root	-rwxr-xr-x	2025-06-03 03:16:16
glib-compile-resources	application/x-pie-executable	44.7 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
glib-compile-schemas	application/x-pie-executable	48.85 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
glib-genmarshal	text/x-script.python	39.96 KB	root/root	-rwxr-xr-x	2024-11-05 02:02:31
glib-gettextize	text/x-shellscript	5.25 KB	root/root	-rwxr-xr-x	2024-11-05 02:02:30
glib-mkenums	text/x-script.python	27.15 KB	root/root	-rwxr-xr-x	2024-11-05 02:02:31
gmake	application/x-pie-executable	235.32 KB	root/root	-rwxr-xr-x	2022-04-18 04:38:34
gml2gv	application/x-pie-executable	41.23 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
gneqn	text/x-shellscript	908 B	root/root	-rwxr-xr-x	2019-10-13 02:29:37
gnroff	text/x-shellscript	3.23 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:39
goaccess	application/x-executable	610.99 KB	root/root	-rwxr-xr-x	2020-03-29 10:33:00
gobject-query	application/x-pie-executable	12.4 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
gpasswd	application/x-pie-executable	82.16 KB	root/root	-rwsr-xr-x	2024-04-06 02:00:13
gpg	application/x-pie-executable	1.04 MB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpg-agent	application/x-pie-executable	419.29 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpg-connect-agent	application/x-pie-executable	165.3 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpg-error	application/x-pie-executable	34.16 KB	root/root	-rwxr-xr-x	2019-10-12 12:20:46
gpg-error-config	text/x-shellscript	2.26 KB	root/root	-rwxr-xr-x	2019-10-12 12:20:46
gpg-wks-server	application/x-pie-executable	206.69 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpg-zip	text/x-shellscript	3.44 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:00
gpg2	application/x-pie-executable	1.04 MB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpgconf	application/x-pie-executable	176.09 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpgme-json	application/x-pie-executable	85.68 KB	root/root	-rwxr-xr-x	2024-04-06 12:29:34
gpgparsemail	application/x-pie-executable	28.74 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpgrt-config	text/x-shellscript	2.26 KB	root/root	-rwxr-xr-x	2019-10-12 12:20:46
gpgsplit	application/x-pie-executable	87.02 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpgv	application/x-pie-executable	451.58 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpgv2	application/x-pie-executable	451.58 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
gpic	application/x-pie-executable	293.84 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
gprof	application/x-pie-executable	103.36 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
gr2fonttest	application/x-pie-executable	29.95 KB	root/root	-rwxr-xr-x	2019-11-06 07:45:54
graphml2gv	application/x-pie-executable	20.65 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
grep	application/x-pie-executable	193.63 KB	root/root	-rwxr-xr-x	2019-10-11 03:15:57
gresource	application/x-pie-executable	20.51 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
groff	application/x-pie-executable	124.92 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
grops	application/x-pie-executable	191.14 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
grotty	application/x-pie-executable	141.9 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
groups	application/x-pie-executable	37.47 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
gsettings	application/x-pie-executable	28.61 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
gsoelim	application/x-pie-executable	42.55 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
gss-client	application/x-pie-executable	24.56 KB	root/root	-rwxr-xr-x	2025-06-03 02:06:30
gstack	text/x-shellscript	1.04 KB	root/root	-rwxr-xr-x	2023-10-11 07:09:51
gtar	application/x-pie-executable	448.99 KB	root/root	-rwxr-xr-x	2025-06-11 02:11:24
gtbl	application/x-pie-executable	154.61 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
gtester	application/x-pie-executable	24.51 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:30
gtester-report	text/x-script.python	18.4 KB	root/root	-rwxr-xr-x	2024-11-05 02:03:12
gtk-query-immodules-2.0-64	application/x-pie-executable	16.29 KB	root/root	-rwxr-xr-x	2021-04-06 01:52:34
gtk-update-icon-cache	application/x-pie-executable	33.03 KB	root/root	-rwxr-xr-x	2024-09-24 02:16:12
gtroff	application/x-pie-executable	805.02 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
guild	text/x-shellscript	2.8 KB	root/root	-rwxr-xr-x	2019-10-13 01:11:51
guile	application/x-pie-executable	13.16 KB	root/root	-rwxr-xr-x	2019-10-13 01:18:59
guile-tools	text/x-shellscript	2.8 KB	root/root	-rwxr-xr-x	2019-10-13 01:11:51
guile2	application/x-pie-executable	13.16 KB	root/root	-rwxr-xr-x	2019-10-13 01:18:59
guile2-tools	text/x-shellscript	2.8 KB	root/root	-rwxr-xr-x	2019-10-13 01:11:51
gunzip	text/x-shellscript	2.29 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
gv2gml	application/x-pie-executable	24.7 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gv2gxl	application/x-pie-executable	41.3 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gvcolor	application/x-pie-executable	46.9 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gvgen	application/x-pie-executable	24.8 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gvmap	application/x-pie-executable	526.31 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gvmap.sh	text/x-shellscript	2.14 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:07
gvpack	application/x-pie-executable	460.59 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gvpr	application/x-pie-executable	7.83 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gxl2dot	application/x-pie-executable	41.3 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gxl2gv	application/x-pie-executable	41.3 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
gzexe	text/x-shellscript	6.23 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
gzip	application/x-pie-executable	94.67 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:29
h2ph	text/x-perl	28.69 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:25
h2xs	text/x-perl	59.44 KB	root/root	-rwxr-xr-x	2023-05-18 09:34:54
hash	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
head	application/x-pie-executable	45.58 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
hexdump	application/x-pie-executable	57.5 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
hmac256	application/x-pie-executable	16.86 KB	root/root	-rwxr-xr-x	2022-06-28 11:54:07
host	application/x-pie-executable	142.3 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
hostid	application/x-pie-executable	33.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
hostname	application/x-pie-executable	21.16 KB	root/root	-rwxr-xr-x	2019-10-11 01:06:51
hostnamectl	application/x-pie-executable	20.83 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
htop	application/x-pie-executable	304.73 KB	root/root	-rwxr-xr-x	2022-07-21 02:42:05
hunspell	application/x-pie-executable	144.7 KB	root/root	-rwxr-xr-x	2019-10-13 08:33:15
i386	application/x-pie-executable	20.76 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
iceauth	application/x-pie-executable	41.87 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
iconv	application/x-pie-executable	61.44 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
icu-config	text/x-shellscript	191 B	root/root	-rwxr-xr-x	2018-05-04 03:40:07
icu-config-64	text/x-shellscript	21.5 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:31
icuinfo	application/x-pie-executable	18.15 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
id	application/x-pie-executable	45.52 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
identify	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
idn	application/x-pie-executable	39.41 KB	root/root	-rwxr-xr-x	2019-10-13 04:55:35
ifnames	text/x-perl	4.03 KB	root/root	-rwxr-xr-x	2024-08-13 07:30:48
imh-procwatch	text/x-script.python	25.38 KB	root/root	-rwxr-xr-x	2025-05-01 04:05:57
imh-python3	application/x-pie-executable	4.26 MB	root/root	-rwxr-xr-x	2025-05-05 04:25:37
imh-python3.13	text/x-shellscript	54 B	root/root	-rwxr-xr-x	2025-05-06 08:30:51
imh-python3.9	application/x-pie-executable	4.26 MB	root/root	-rwxr-xr-x	2025-05-05 04:25:37
imh-scan	text/x-script.python	14.33 KB	root/root	-rwxr-xr-x	2025-05-01 04:05:57
import	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
info	application/x-pie-executable	249.89 KB	root/root	-rwxr-xr-x	2022-04-18 05:09:26
infocmp	application/x-pie-executable	61.05 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
infotocap	application/x-pie-executable	85.31 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
innochecksum	application/x-pie-executable	3.59 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
install	application/x-pie-executable	156.25 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
instmodsh	text/x-perl	4.1 KB	root/root	-rwxr-xr-x	2019-10-13 08:55:21
ionice	application/x-pie-executable	28.98 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
iostat	application/x-pie-executable	57.69 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
ipcalc	application/x-pie-executable	46.08 KB	root/root	-rwxr-xr-x	2020-05-31 07:39:31
ipcmk	application/x-pie-executable	29.14 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
ipcrm	application/x-pie-executable	28.99 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
ipcs	application/x-pie-executable	53.39 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
iptables-xml	application/x-pie-executable	92.18 KB	root/root	-rwxr-xr-x	2023-10-16 07:15:58
isosize	application/x-pie-executable	24.88 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
ispell	text/x-shellscript	988 B	root/root	-rwxr-xr-x	2022-04-18 03:10:51
jobs	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
join	application/x-pie-executable	53.77 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
journalctl	application/x-pie-executable	76.99 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
json_pp	text/x-perl	4.19 KB	root/root	-rwxr-xr-x	2019-10-14 12:12:07
kbd_mode	application/x-pie-executable	12.55 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
kbdinfo	application/x-pie-executable	16.56 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
kbdrate	application/x-pie-executable	16.45 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
kernel-install	text/x-shellscript	4.41 KB	root/root	-rwxr-xr-x	2018-06-22 11:11:49
kill	application/x-pie-executable	37.27 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
killall	application/x-pie-executable	29.77 KB	root/root	-rwxr-xr-x	2020-11-06 02:24:16
kmod	application/x-pie-executable	159.95 KB	root/root	-rwxr-xr-x	2024-04-08 09:18:53
krb5-config	text/x-shellscript	6.98 KB	root/root	-rwxr-xr-x	2025-06-03 02:06:28
l4p-tmpl	text/x-perl	1.8 KB	root/root	-rwxr-xr-x	2020-07-22 10:35:39
last	application/x-pie-executable	49.23 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lastb	application/x-pie-executable	49.23 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lastcomm	application/x-pie-executable	37.8 KB	root/root	-rwxr-xr-x	2019-10-21 04:09:19
lastlog	application/x-pie-executable	20.62 KB	root/root	-rwxr-xr-x	2024-04-06 02:00:13
lchfn	application/x-pie-executable	20.35 KB	root/root	-rwxr-xr-x	2024-09-24 02:24:38
lchsh	application/x-pie-executable	16.35 KB	root/root	-rwxr-xr-x	2024-09-24 02:24:38
ld	application/x-pie-executable	1.71 MB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
ld.bfd	application/x-pie-executable	1.71 MB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
ld.gold	application/x-pie-executable	2.35 MB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
ld.so	application/x-pie-executable	1.05 MB	root/root	-rwxr-xr-x	2025-06-09 08:31:30
ldd	text/x-shellscript	5.31 KB	root/root	-rwxr-xr-x	2025-06-09 08:25:41
lefty	application/x-pie-executable	304.52 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
less	application/x-pie-executable	173.76 KB	root/root	-rwxr-xr-x	2024-07-02 08:10:37
lessecho	application/x-pie-executable	12.4 KB	root/root	-rwxr-xr-x	2024-07-02 08:10:37
lesskey	application/x-pie-executable	21.99 KB	root/root	-rwxr-xr-x	2024-07-02 08:10:37
lesspipe.sh	text/x-shellscript	3.07 KB	root/root	-rwxr-xr-x	2024-07-02 07:57:10
lex	application/x-pie-executable	428.45 KB	root/root	-rwxr-xr-x	2019-10-12 12:33:17
lexgrog	application/x-pie-executable	93.7 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
libgcrypt-config	text/x-shellscript	3.84 KB	root/root	-rwxr-xr-x	2022-06-28 11:54:07
libmcrypt-config	text/x-shellscript	1.38 KB	root/root	-rwxr-xr-x	2003-03-08 05:31:51
libnetcfg	text/x-perl	15.41 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:25
libpng-config	text/x-shellscript	2.33 KB	root/root	-rwxr-xr-x	2019-10-12 12:44:13
libpng16-config	text/x-shellscript	2.33 KB	root/root	-rwxr-xr-x	2019-10-12 12:44:13
link	application/x-pie-executable	33.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
links	application/x-pie-executable	1.55 MB	root/root	-rwxr-xr-x	2019-10-14 07:31:15
linux32	application/x-pie-executable	20.76 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
linux64	application/x-pie-executable	20.76 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
ln	application/x-pie-executable	70.57 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
lneato	text/x-shellscript	1.51 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:07
loadkeys	application/x-pie-executable	210.53 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
loadunimap	application/x-pie-executable	29.03 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
locale	application/x-pie-executable	56.45 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
localectl	application/x-pie-executable	28.86 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
localedef	application/x-pie-executable	307.47 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
locate		47.41 KB	root/slocate	-rwx--s--x	2019-10-14 03:43:04
lockfile	application/x-pie-executable	23.91 KB	root/mail	-rwxr-sr-x	2019-10-12 11:30:08
logger	application/x-pie-executable	49.98 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
login	application/x-pie-executable	40.96 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
loginctl	application/x-pie-executable	57.28 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
logname	application/x-pie-executable	33.42 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
look	application/x-pie-executable	16.45 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
ls	application/x-pie-executable	139.97 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
lsattr	application/x-pie-executable	11.93 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:19
lsblk	application/x-pie-executable	90.13 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lscpu	application/x-pie-executable	81.7 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lsipc	application/x-pie-executable	73.74 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lslocks	application/x-pie-executable	37.53 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lslogins	application/x-pie-executable	65.6 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lsmem	application/x-pie-executable	45.34 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lsns	application/x-pie-executable	49.28 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
lsof	application/x-pie-executable	175.4 KB	root/root	-rwxr-xr-x	2020-08-15 09:59:43
lwp-download	text/x-perl	10.05 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
lwp-dump	text/x-perl	2.65 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
lwp-mirror	text/x-perl	2.36 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
lwp-request	text/x-perl	15.84 KB	root/root	-rwxr-xr-x	2022-04-22 08:13:06
lynx	application/x-pie-executable	1.84 MB	root/root	-rwxr-xr-x	2022-04-18 09:01:05
lzop	application/x-pie-executable	81.86 KB	root/root	-rwxr-xr-x	2019-10-14 03:45:58
m4	application/x-pie-executable	185.56 KB	root/root	-rwxr-xr-x	2019-10-11 02:41:40
mail	application/x-pie-executable	408.89 KB	root/root	-rwxr-xr-x	2019-10-13 12:19:50
mailq	application/x-pie-executable	28.48 KB	root/root	-rwxr-xr-x	2023-10-14 07:38:09
mailq.postfix	application/x-pie-executable	28.48 KB	root/root	-rwxr-xr-x	2023-10-14 07:38:09
mailstat	text/x-shellscript	5.72 KB	root/root	-rwxr-xr-x	2019-10-12 11:30:08
mailx	application/x-pie-executable	408.89 KB	root/root	-rwxr-xr-x	2019-10-13 12:19:50
make	application/x-pie-executable	235.32 KB	root/root	-rwxr-xr-x	2022-04-18 04:38:34
make-dummy-cert	text/x-shellscript	610 B	root/root	-rwxr-xr-x	2024-10-09 01:39:22
makeconv	application/x-pie-executable	66.63 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
makedb	application/x-pie-executable	24.84 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
man	application/x-pie-executable	112.52 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
mandb	application/x-pie-executable	134.52 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
manpath	application/x-pie-executable	33.42 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
mapscrn	application/x-pie-executable	24.84 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
mariadb	application/x-pie-executable	4.34 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-access	text/x-perl	109.34 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-admin	application/x-pie-executable	3.88 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-binlog	application/x-pie-executable	4.14 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-check	application/x-pie-executable	3.88 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-config	application/x-pie-executable	12.2 KB	root/root	-rwxr-xr-x	2025-04-27 07:46:08
mariadb-conv	application/x-pie-executable	3.59 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-convert-table-format	text/x-perl	4.12 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-dump	application/x-pie-executable	3.96 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-dumpslow	text/x-perl	8.05 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-embedded	application/x-pie-executable	22.58 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-find-rows	text/x-perl	3.21 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-fix-extensions	text/x-perl	1.22 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-hotcopy	text/x-perl	34.15 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-import	application/x-pie-executable	3.87 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-install-db	text/x-shellscript	22.46 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-plugin	application/x-pie-executable	3.57 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-secure-installation	text/x-shellscript	13.49 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-service-convert	text/x-shellscript	2.45 KB	root/root	-rwxr-xr-x	2025-04-27 06:05:50
mariadb-setpermission	text/x-perl	17.56 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadb-show	application/x-pie-executable	3.87 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-slap	application/x-pie-executable	3.88 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-tzinfo-to-sql	application/x-pie-executable	3.56 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb-upgrade	application/x-pie-executable	4 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
mariadb-waitpid	application/x-pie-executable	3.55 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mariadb_config	application/x-pie-executable	12.2 KB	root/root	-rwxr-xr-x	2025-04-27 07:46:08
mariadbd-multi	text/x-perl	26.71 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadbd-safe	text/x-shellscript	30.42 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mariadbd-safe-helper	application/x-pie-executable	3.52 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
mcookie	application/x-pie-executable	33.26 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
mcpp	application/x-pie-executable	9.02 KB	root/root	-rwxr-xr-x	2019-10-14 03:45:04
md5sum	application/x-pie-executable	45.62 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
mdig	application/x-pie-executable	48.52 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
mdsearch	application/x-pie-executable	85.05 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
melt	application/x-pie-executable	32.39 KB	root/root	-rwxr-xr-x	2019-07-23 09:19:31
memaslap	application/x-pie-executable	70.12 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memcapable	application/x-pie-executable	62.87 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memcat	application/x-pie-executable	21.29 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memcp	application/x-pie-executable	25.44 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memdump	application/x-pie-executable	21.23 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memerror	application/x-pie-executable	16.98 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memexist	application/x-pie-executable	21.06 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memflush	application/x-pie-executable	21.23 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memparse	application/x-pie-executable	12.29 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memping	application/x-pie-executable	21.23 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memrm	application/x-pie-executable	21.09 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memslap	application/x-pie-executable	29.66 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memstat	application/x-pie-executable	25.35 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
memtouch	application/x-pie-executable	21.27 KB	root/root	-rwxr-xr-x	2022-04-18 04:36:23
mesg	application/x-pie-executable	16.36 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
miltertest	application/x-pie-executable	56.82 KB	root/root	-rwxr-xr-x	2023-04-16 07:11:38
mimedump	text/x-perl	2.29 KB	root/root	-rwxr-xr-x	2015-06-19 01:22:05
mimeencode	text/x-perl	849 B	root/root	-rwxr-xr-x	2015-06-19 01:22:05
mimeexplode	text/x-perl	3.28 KB	root/root	-rwxr-xr-x	2015-06-19 01:22:05
mimepostcard	text/x-perl	2.68 KB	root/root	-rwxr-xr-x	2015-06-19 01:22:05
mimesend	text/x-perl	3.06 KB	root/root	-rwxr-xr-x	2015-06-19 01:22:05
mkdir	application/x-pie-executable	82.79 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
mkfifo	application/x-pie-executable	66.56 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
mkfontdir	text/x-shellscript	65 B	root/root	-rwxr-xr-x	2021-10-09 11:42:24
mkfontscale	application/x-pie-executable	41.59 KB	root/root	-rwxr-xr-x	2021-10-09 11:42:47
mknod	application/x-pie-executable	70.55 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
mktemp	application/x-pie-executable	45.73 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
mm2gv	application/x-pie-executable	90.53 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
mmdblookup	application/x-pie-executable	16.74 KB	root/root	-rwxr-xr-x	2024-02-12 02:30:34
modulemd-validator	application/x-pie-executable	24.96 KB	root/root	-rwxr-xr-x	2021-10-09 01:37:57
mogrify	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
monit	application/x-pie-executable	847.19 KB	root/root	-rwxr-xr-x	2024-01-18 10:17:54
montage	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
more	application/x-pie-executable	44.94 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
mount	application/x-pie-executable	49.15 KB	root/root	-rwsr-xr-x	2024-04-06 01:02:53
mountpoint	application/x-pie-executable	16.48 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
mpicalc	application/x-pie-executable	20.38 KB	root/root	-rwxr-xr-x	2022-06-28 11:54:07
mpstat	application/x-pie-executable	53.51 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
msql2mysql	text/x-shellscript	1.41 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mv	application/x-pie-executable	144.03 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
mvxattr	application/x-pie-executable	16.27 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
my_print_defaults	application/x-pie-executable	3.56 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
myisam_ftdump	application/x-pie-executable	3.89 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
myisamchk	application/x-pie-executable	4.01 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
myisamlog	application/x-pie-executable	3.87 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
myisampack	application/x-pie-executable	3.91 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
mysql	application/x-pie-executable	4.34 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysql_config	text/x-shellscript	4.51 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysql_embedded	application/x-pie-executable	22.58 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysql_find_rows	text/x-perl	3.21 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysql_fix_extensions	text/x-perl	1.22 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysql_install_db	text/x-shellscript	22.46 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysql_plugin	application/x-pie-executable	3.57 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysql_tzinfo_to_sql	application/x-pie-executable	3.56 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysql_upgrade	application/x-pie-executable	4 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
mysql_waitpid	application/x-pie-executable	3.55 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqlaccess	text/x-perl	109.34 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysqladmin	application/x-pie-executable	3.88 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqlbinlog	application/x-pie-executable	4.14 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqlcheck	application/x-pie-executable	3.88 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqld_multi	text/x-perl	26.71 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysqld_safe	text/x-shellscript	30.42 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
mysqld_safe_helper	application/x-pie-executable	3.52 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
mysqldump	application/x-pie-executable	3.96 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqlimport	application/x-pie-executable	3.87 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqlshow	application/x-pie-executable	3.87 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mysqlslap	application/x-pie-executable	3.88 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
mytop	text/x-perl	71.95 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
nail	application/x-pie-executable	408.89 KB	root/root	-rwxr-xr-x	2019-10-13 12:19:50
named-rrchecker	application/x-pie-executable	19.88 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
namei	application/x-pie-executable	33.1 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
nano	application/x-pie-executable	247.94 KB	root/root	-rwxr-xr-x	2024-09-24 02:16:19
ncurses6-config	text/x-shellscript	5.87 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:41
ncursesw6-config	text/x-shellscript	5.88 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:41
neato	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
neqn	text/x-shellscript	908 B	root/root	-rwxr-xr-x	2019-10-13 02:29:37
net	application/x-pie-executable	1.02 MB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
net-server	text/x-perl	3.34 KB	root/root	-rwxr-xr-x	2019-10-16 09:10:12
net-snmp-config	text/x-shellscript	1.37 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:35
net-snmp-config-x86_64	text/x-shellscript	32.82 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:25
net-snmp-create-v3-user	text/x-shellscript	3.15 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:25
netstat	application/x-pie-executable	158.68 KB	root/root	-rwxr-xr-x	2020-08-30 05:47:39
newaliases	application/x-pie-executable	28.48 KB	root/root	-rwxr-xr-x	2023-10-14 07:38:09
newaliases.postfix	application/x-pie-executable	28.48 KB	root/root	-rwxr-xr-x	2023-10-14 07:38:09
newgidmap	application/x-pie-executable	47.8 KB	root/root	-rwxr-xr-x	2024-04-06 02:00:13
newgrp	application/x-pie-executable	42.45 KB	root/root	-rwsr-xr-x	2024-04-06 02:00:13
newuidmap	application/x-pie-executable	47.76 KB	root/root	-rwxr-xr-x	2024-04-06 02:00:13
nginx-upgrade	text/x-shellscript	560 B	root/root	-rwxr-xr-x	2021-04-19 10:05:11
nice	application/x-pie-executable	37.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
nisdomainname	application/x-pie-executable	21.16 KB	root/root	-rwxr-xr-x	2019-10-11 01:06:51
nl	application/x-pie-executable	45.63 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
nm	application/x-pie-executable	50.38 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
nmblookup	application/x-pie-executable	149.84 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
node	application/x-pie-executable	29.74 MB	root/root	-rwxr-xr-x	2021-03-10 02:50:51
nohup	application/x-pie-executable	37.48 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
nomarch	application/x-executable	27.31 KB	root/root	-rwxr-xr-x	2019-07-23 09:21:59
nop	application/x-pie-executable	12.5 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
npm	application/javascript	2.83 KB	root/root	-rwxr-xr-x	2021-03-10 02:36:35
nproc	application/x-pie-executable	37.48 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
npx	application/javascript	173 B	root/root	-rwxr-xr-x	2021-03-10 02:36:35
nroff	text/x-shellscript	3.23 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:39
nsenter	application/x-pie-executable	33.3 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
nslookup	application/x-pie-executable	146.26 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
nsupdate	application/x-pie-executable	73.05 KB	root/root	-rwxr-xr-x	2025-02-20 09:05:41
numfmt	application/x-pie-executable	65.71 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
oLschema2ldif	application/x-pie-executable	24.47 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
objcopy	application/x-pie-executable	240.07 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
objdump	application/x-pie-executable	419.76 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
od	application/x-pie-executable	73.88 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
onig-config	text/x-shellscript	1.31 KB	root/root	-rwxr-xr-x	2024-04-06 01:53:51
opax	application/x-pie-executable	119.15 KB	root/root	-rwxr-xr-x	2023-06-27 05:55:10
open	application/x-pie-executable	20.97 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
openssl	application/x-pie-executable	745.95 KB	root/root	-rwxr-xr-x	2024-10-09 01:39:36
openvt	application/x-pie-executable	20.97 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
osage	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
p11-kit	application/x-pie-executable	37.15 KB	root/root	-rwxr-xr-x	2024-04-06 02:16:19
package-stash-conflicts	text/x-perl	842 B	root/root	-rwxr-xr-x	2019-10-13 11:27:56
pango-list	application/x-pie-executable	11.88 KB	root/root	-rwxr-xr-x	2021-10-08 03:22:06
pango-view	application/x-pie-executable	57.44 KB	root/root	-rwxr-xr-x	2021-10-08 03:22:06
paperconf	application/x-pie-executable	13.07 KB	root/root	-rwxr-xr-x	2019-10-12 08:09:13
passwd	application/x-pie-executable	32.77 KB	root/root	-rwsr-xr-x	2022-04-18 10:59:33
paste	application/x-pie-executable	37.46 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
patch	application/x-pie-executable	206.46 KB	root/root	-rwxr-xr-x	2020-06-01 03:14:25
patchwork	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
pathchk	application/x-pie-executable	37.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
pax	application/x-pie-executable	119.15 KB	root/root	-rwxr-xr-x	2023-06-27 05:55:10
pcre-config	text/x-shellscript	2.09 KB	root/root	-rwxr-xr-x	2021-10-08 07:17:42
pcre2-config	text/x-shellscript	1.9 KB	root/root	-rwxr-xr-x	2022-08-02 04:07:28
pdbedit	application/x-pie-executable	48.54 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
peekfd	application/x-pie-executable	16.51 KB	root/root	-rwxr-xr-x	2020-11-06 02:24:16
perl	application/x-pie-executable	12.44 KB	root/root	-rwxr-xr-x	2023-05-18 09:35:10
perl5.26.3	application/x-pie-executable	12.44 KB	root/root	-rwxr-xr-x	2023-05-18 09:35:10
perlbug	text/x-perl	44.39 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:25
perldoc	text/x-perl	118 B	root/root	-rwxr-xr-x	2019-10-13 11:53:57
perlivp	text/x-perl	10.56 KB	root/root	-rwxr-xr-x	2023-05-18 09:34:54
perlthanks	text/x-perl	44.39 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:25
perltidy	text/x-perl	129.13 KB	root/root	-rwxr-xr-x	2019-10-13 02:41:58
perror	application/x-pie-executable	3.75 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
pflags	text/plain	2.57 KB	root/root	-rwxr-xr-x	2024-04-06 01:32:49
pftp	application/x-pie-executable	101.2 KB	root/root	-rwxr-xr-x	2019-10-12 12:59:55
pg_config	application/x-pie-executable	45.35 KB	root/root	-rwxr-xr-x	2025-02-20 07:58:19
pgrep	application/x-pie-executable	28.84 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
php	application/x-executable	66.48 MB	root/root	-rwxr-xr-x	2025-03-06 11:00:38
pic	application/x-pie-executable	293.84 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
piconv	text/x-perl	8.08 KB	root/root	-rwxr-xr-x	2019-10-13 08:46:10
pidof	application/x-pie-executable	16.7 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
pidstat	application/x-pie-executable	65.72 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
ping	application/x-pie-executable	66.13 KB	root/root	-rwxr-xr-x	2023-10-14 05:19:01
pinky	application/x-pie-executable	41.53 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
pip-3	text/x-script.python	209 B	root/root	-rwxr-xr-x	2024-04-06 01:40:45
pip-3.6	text/x-script.python	209 B	root/root	-rwxr-xr-x	2024-04-06 01:40:45
pip-3.8	text/x-script.python	536 B	root/root	-rwxr-xr-x	2023-10-17 06:30:25
pip3	text/x-script.python	209 B	root/root	-rwxr-xr-x	2024-04-06 01:40:45
pip3.6	text/x-script.python	209 B	root/root	-rwxr-xr-x	2024-04-06 01:40:45
pip3.8	text/x-script.python	536 B	root/root	-rwxr-xr-x	2023-10-17 06:30:25
pkg-config	application/x-pie-executable	40.04 KB	root/root	-rwxr-xr-x	2019-10-13 06:57:31
pkgconf	application/x-pie-executable	40.04 KB	root/root	-rwxr-xr-x	2019-10-13 06:57:31
pkgdata	application/x-pie-executable	62.72 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
pkill	application/x-pie-executable	28.84 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
pl2pm	text/x-perl	4.43 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:00
pldd	application/x-pie-executable	16.75 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
pmap	application/x-pie-executable	32.78 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
png-fix-itxt	application/x-pie-executable	13.04 KB	root/root	-rwxr-xr-x	2019-10-12 12:44:13
pngfix	application/x-pie-executable	53.53 KB	root/root	-rwxr-xr-x	2019-10-12 12:44:13
pod2html	text/x-perl	4.04 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:25
pod2man	text/x-perl	14.68 KB	root/root	-rwxr-xr-x	2019-10-13 02:12:32
pod2text	text/x-perl	10.55 KB	root/root	-rwxr-xr-x	2019-10-13 02:12:32
pod2usage	text/x-perl	3.86 KB	root/root	-rwxr-xr-x	2019-10-13 11:57:18
podchecker	text/x-perl	3.57 KB	root/root	-rwxr-xr-x	2019-10-13 11:46:35
podselect	text/x-perl	2.47 KB	root/root	-rwxr-xr-x	2019-10-13 11:52:55
post-grohtml	application/x-pie-executable	238.73 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
pr	application/x-pie-executable	82.23 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
pre-grohtml	application/x-pie-executable	130.55 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
precat	text/x-shellscript	5.52 KB	root/root	-rwxr-xr-x	2022-04-18 03:10:50
preconv	application/x-pie-executable	57.65 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
preunzip	text/x-shellscript	5.52 KB	root/root	-rwxr-xr-x	2022-04-18 03:10:50
prezip	text/x-shellscript	5.52 KB	root/root	-rwxr-xr-x	2022-04-18 03:10:50
prezip-bin	application/x-pie-executable	11.98 KB	root/root	-rwxr-xr-x	2022-04-18 03:10:53
printenv	application/x-pie-executable	33.4 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
printf	application/x-pie-executable	53.64 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
prlimit	application/x-pie-executable	37.54 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
procan	application/x-pie-executable	82.65 KB	root/root	-rwxr-xr-x	2021-10-08 03:43:20
procmail	application/x-pie-executable	116.16 KB	root/mail	-rwxr-xr-x	2019-10-12 11:30:08
profiles	application/x-pie-executable	53 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
prove	text/x-perl	13.24 KB	root/root	-rwxr-xr-x	2019-10-13 12:42:34
prtstat	application/x-pie-executable	20.51 KB	root/root	-rwxr-xr-x	2020-11-06 02:24:16
prune	application/x-pie-executable	16.73 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
ps	application/x-pie-executable	134.75 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
psfaddtable	application/x-pie-executable	20.66 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
psfgettable	application/x-pie-executable	20.66 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
psfstriptable	application/x-pie-executable	20.66 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
psfxtable	application/x-pie-executable	20.66 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
pslog	application/x-pie-executable	12.48 KB	root/root	-rwxr-xr-x	2020-11-06 02:24:16
pspell-config	text/x-shellscript	384 B	root/root	-rwxr-xr-x	2022-04-18 03:10:50
pstack	text/x-shellscript	1.04 KB	root/root	-rwxr-xr-x	2023-10-11 07:09:51
pstree	application/x-pie-executable	33.53 KB	root/root	-rwxr-xr-x	2020-11-06 02:24:16
pstree.x11	application/x-pie-executable	33.53 KB	root/root	-rwxr-xr-x	2020-11-06 02:24:16
pt-align	text/x-perl	39.89 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-archiver	text/x-perl	255.74 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-config-diff	text/x-perl	164.27 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-deadlock-logger	text/x-perl	161.56 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-diskstats	text/x-perl	160.3 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-duplicate-key-checker	text/x-perl	164.22 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-fifo-split	text/x-perl	48.11 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-find	text/x-perl	145.46 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-fingerprint	text/x-perl	64.85 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-fk-error-logger	text/x-perl	129.3 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-heartbeat	text/x-perl	186.97 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-index-usage	text/x-perl	219.97 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-ioprofile	text/x-shellscript	31.59 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-kill	text/x-perl	242.13 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-mext	text/x-shellscript	21.24 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-mysql-summary	text/x-shellscript	98.62 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-online-schema-change	text/x-perl	374.96 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-pmp	text/x-shellscript	24.02 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-query-digest	text/x-perl	505.41 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-show-grants	text/x-perl	70.84 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-sift	text/x-shellscript	36.84 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-slave-delay	text/x-perl	141.38 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-slave-find	text/x-perl	124 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-slave-restart	text/x-perl	174.58 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-stalk	text/x-shellscript	67.93 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-summary	text/x-shellscript	87.76 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-table-checksum	text/x-perl	408.52 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-table-sync	text/x-perl	386.36 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-table-usage	text/x-perl	217.38 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-upgrade	text/x-perl	322.26 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:24
pt-variable-advisor	text/x-perl	172.12 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
pt-visual-explain	text/x-perl	99.27 KB	root/root	-rwxr-xr-x	2015-11-06 07:56:25
ptar	text/x-perl	3.38 KB	root/root	-rwxr-xr-x	2019-10-13 07:10:48
ptardiff	text/x-perl	2.48 KB	root/root	-rwxr-xr-x	2019-10-13 07:10:48
ptargrep	text/x-perl	4.2 KB	root/root	-rwxr-xr-x	2019-10-13 07:10:48
ptx	application/x-pie-executable	78.07 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
pure-ftpwho	application/x-pie-executable	11.88 KB	root/root	-rwxr-xr-x	2021-10-08 07:29:24
pure-pw	application/x-pie-executable	41.13 KB	root/root	-rwxr-xr-x	2020-05-06 04:49:49
pure-pwconvert	application/x-pie-executable	12.03 KB	root/root	-rwxr-xr-x	2020-05-06 04:49:49
pure-statsdecode	application/x-pie-executable	12.03 KB	root/root	-rwxr-xr-x	2020-05-06 04:49:49
pwd	application/x-pie-executable	37.5 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
pwdx	application/x-pie-executable	12.68 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
pwmake	application/x-pie-executable	12.27 KB	root/root	-rwxr-xr-x	2023-04-01 06:24:17
pwscore	application/x-pie-executable	12.27 KB	root/root	-rwxr-xr-x	2023-04-01 06:24:17
pydoc-3	text/plain	89 B	root/root	-rwxr-xr-x	2024-12-05 01:10:07
pydoc3	text/plain	89 B	root/root	-rwxr-xr-x	2024-12-05 01:10:07
pydoc3.6	text/plain	89 B	root/root	-rwxr-xr-x	2024-12-05 01:10:07
pydoc3.8	text/x-script.python	78 B	root/root	-rwxr-xr-x	2023-10-17 06:12:55
python3	application/x-pie-executable	11.59 KB	root/root	-rwxr-xr-x	2024-12-05 01:10:21
python3.6	application/x-pie-executable	11.59 KB	root/root	-rwxr-xr-x	2024-12-05 01:10:21
python3.6m	application/x-pie-executable	11.59 KB	root/root	-rwxr-xr-x	2024-12-05 01:10:21
python3.8	application/x-pie-executable	7.59 KB	root/root	-rwxr-xr-x	2023-10-17 06:13:13
pyvenv-3	text/plain	446 B	root/root	-rwxr-xr-x	2024-12-05 01:10:07
pyvenv-3.6	text/plain	446 B	root/root	-rwxr-xr-x	2024-12-05 01:10:07
quota	application/x-pie-executable	91.49 KB	root/root	-rwxr-xr-x	2021-10-09 07:08:37
quotasync	application/x-pie-executable	74.69 KB	root/root	-rwxr-xr-x	2021-10-09 07:08:37
ranlib	application/x-pie-executable	61.98 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
raw	application/x-pie-executable	16.49 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
razor-admin	text/x-perl	818 B	root/root	-rwxr-xr-x	2021-12-10 12:26:04
razor-check	text/x-perl	820 B	root/root	-rwxr-xr-x	2021-12-10 12:26:04
razor-client	text/x-perl	537 B	root/root	-rwxr-xr-x	2021-12-10 12:26:04
razor-report	text/x-perl	824 B	root/root	-rwxr-xr-x	2021-12-10 12:26:04
razor-revoke	text/x-perl	824 B	root/root	-rwxr-xr-x	2021-12-10 12:26:04
read	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
readelf	application/x-pie-executable	624.54 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
readlink	application/x-pie-executable	45.96 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
realpath	application/x-pie-executable	50.02 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
rearj	application/x-pie-executable	69.8 KB	root/root	-rwxr-xr-x	2019-07-23 09:41:48
recode	application/x-pie-executable	47.03 KB	root/root	-rwxr-xr-x	2019-10-18 03:18:02
red	text/x-shellscript	89 B	root/root	-rwxr-xr-x	2019-10-11 01:05:14
regdiff	application/x-pie-executable	16.38 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
regpatch	application/x-pie-executable	20.39 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
regshell	application/x-pie-executable	32.63 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
regtree	application/x-pie-executable	20.38 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
rename	application/x-pie-executable	16.5 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
renew-dummy-cert	text/x-shellscript	725 B	root/root	-rwxr-xr-x	2024-10-09 01:39:22
renice	application/x-pie-executable	16.46 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
replace	application/x-pie-executable	3.54 MB	root/root	-rwxr-xr-x	2025-04-27 07:44:44
reset	application/x-pie-executable	24.76 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
resizecons	application/x-pie-executable	20.77 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
resolve_stack_dump	application/x-pie-executable	3.56 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
resolvectl	application/x-pie-executable	195.74 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
resolveip	application/x-pie-executable	3.56 MB	root/root	-rwxr-xr-x	2025-04-27 07:50:33
restic	application/x-pie-executable	27.02 MB	root/root	-rwxr-xr-x	2024-11-11 08:47:35
rev	application/x-pie-executable	12.45 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
rm	application/x-pie-executable	70.47 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
rmail	text/x-shellscript	262 B	root/root	-rwxr-xr-x	2023-10-14 07:38:08
rmail.postfix	text/x-shellscript	262 B	root/root	-rwxr-xr-x	2023-10-14 07:38:08
rmdir	application/x-pie-executable	45.54 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
rnano	application/x-pie-executable	247.94 KB	root/root	-rwxr-xr-x	2024-09-24 02:16:19
rpcbind	application/x-pie-executable	61.55 KB	root/root	-rwxr-xr-x	2022-10-12 11:00:54
rpcclient	application/x-pie-executable	1.42 MB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
rpcinfo	application/x-pie-executable	32.64 KB	root/root	-rwxr-xr-x	2022-10-12 11:00:54
rpm	application/x-pie-executable	20.85 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpm2archive	application/x-pie-executable	20.46 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpm2cpio	application/x-pie-executable	11.84 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpmdb	application/x-pie-executable	16.96 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpmgraph	application/x-pie-executable	16.16 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpmkeys	application/x-pie-executable	16.87 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpmquery	application/x-pie-executable	20.85 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rpmverify	application/x-pie-executable	20.85 KB	root/root	-rwxr-xr-x	2024-12-17 04:11:05
rsync	application/x-pie-executable	510.15 KB	root/root	-rwxr-xr-x	2025-06-03 02:02:49
rsyslog-recover-qi.pl	text/x-perl	5.96 KB	root/root	-rwxr-xr-x	2024-11-05 02:34:12
run-parts	text/x-shellscript	1.94 KB	root/root	-rwxr-xr-x	2021-04-08 09:38:36
run-with-aspell	text/x-shellscript	85 B	root/root	-rwxr-xr-x	2022-04-18 03:10:50
runcon	application/x-pie-executable	37.45 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
rvi	application/x-pie-executable	1.13 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
rview	application/x-pie-executable	1.13 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
rvim	application/x-pie-executable	2.93 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
sa-awl	text/x-perl	4.9 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:53
sa-check_spamd	text/x-perl	14.52 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:53
sa-learn	text/x-perl	44.83 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:53
sa-update	text/x-perl	72.6 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:58
sadf	application/x-pie-executable	334.57 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
samba-log-parser	text/x-script.python	12.86 KB	root/root	-rwxr-xr-x	2023-07-28 12:14:20
samba-regedit	application/x-pie-executable	111.08 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
sar	application/x-pie-executable	135.77 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
sasl2-sample-client	application/x-pie-executable	20.84 KB	root/root	-rwxr-xr-x	2022-02-23 08:13:56
sasl2-sample-server	application/x-pie-executable	24.7 KB	root/root	-rwxr-xr-x	2022-02-23 08:13:56
scalar	application/x-pie-executable	2.18 MB	root/root	-rwxr-xr-x	2025-06-03 03:16:16
sccmap	application/x-pie-executable	20.62 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
scp	application/x-pie-executable	102.85 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
screen	application/x-pie-executable	482.46 KB	root/screen	-rwxr-sr-x	2021-05-05 10:04:06
script	application/x-pie-executable	36.79 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
scriptreplay	application/x-pie-executable	28.99 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
sdiff	application/x-pie-executable	105.33 KB	root/root	-rwxr-xr-x	2020-05-04 03:15:14
secon	application/x-pie-executable	25.46 KB	root/root	-rwxr-xr-x	2024-07-02 09:04:21
sed	application/x-pie-executable	115.48 KB	root/root	-rwxr-xr-x	2022-04-18 09:41:04
semodule_expand	application/x-pie-executable	12.28 KB	root/root	-rwxr-xr-x	2024-07-02 09:04:21
semodule_link	application/x-pie-executable	12.28 KB	root/root	-rwxr-xr-x	2024-07-02 09:04:21
semodule_package	application/x-pie-executable	16.68 KB	root/root	-rwxr-xr-x	2024-07-02 09:04:21
semodule_unpackage	application/x-pie-executable	12.3 KB	root/root	-rwxr-xr-x	2024-07-02 09:04:21
seq	application/x-pie-executable	53.52 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sessreg	application/x-pie-executable	17.38 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
setarch	application/x-pie-executable	20.76 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
setfacl	application/x-pie-executable	37.65 KB	root/root	-rwxr-xr-x	2024-04-06 12:15:42
setfattr	application/x-pie-executable	23.19 KB	root/root	-rwxr-xr-x	2019-10-11 05:58:09
setfont	application/x-pie-executable	45.19 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
setkeycodes	application/x-pie-executable	12.56 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
setleds	application/x-pie-executable	16.6 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
setmetamode	application/x-pie-executable	12.56 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
setpriv	application/x-pie-executable	45.15 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
setsid	application/x-pie-executable	16.38 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
setterm	application/x-pie-executable	45.12 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
setvtrgb	application/x-pie-executable	16.64 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
sfdp	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
sftp	application/x-pie-executable	159.74 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
sg	application/x-pie-executable	42.45 KB	root/root	-rwsr-xr-x	2024-04-06 02:00:13
sh	application/x-pie-executable	1.1 MB	root/root	-rwxr-xr-x	2024-05-23 08:55:42
sha1sum	application/x-pie-executable	45.63 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sha224sum	application/x-pie-executable	45.66 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sha256sum	application/x-pie-executable	45.66 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sha384sum	application/x-pie-executable	45.66 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sha512sum	application/x-pie-executable	45.66 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sharesec	application/x-pie-executable	40.58 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
shasum	text/x-perl	9.66 KB	root/root	-rwxr-xr-x	2019-10-14 12:00:12
showconsolefont	application/x-pie-executable	20.73 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
showkey	application/x-pie-executable	16.58 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
showrgb	application/x-pie-executable	13.05 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
shred	application/x-pie-executable	61.94 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
shuf	application/x-pie-executable	58.16 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sieve-dump	application/x-pie-executable	24.62 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
sieve-filter	application/x-pie-executable	32.62 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
sieve-test	application/x-pie-executable	32.76 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
sievec	application/x-pie-executable	28.63 KB	root/root	-rwxr-xr-x	2024-09-24 08:31:32
sigtool	application/x-pie-executable	201.3 KB	root/root	-rwxr-xr-x	2025-01-26 09:21:51
sim_client	application/x-pie-executable	16.28 KB	root/root	-rwxr-xr-x	2025-06-03 02:06:30
size	application/x-pie-executable	33.25 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
skill	application/x-pie-executable	28.8 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
slabtop	application/x-pie-executable	20.84 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
sleep	application/x-pie-executable	37.47 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
smbcacls	application/x-pie-executable	52.72 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbclient	application/x-pie-executable	157.99 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbcontrol	application/x-pie-executable	61.42 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbcquotas	application/x-pie-executable	28.56 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbget	application/x-pie-executable	32.63 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbpasswd	application/x-pie-executable	40.49 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbprint	text/x-shellscript	2.22 KB	root/root	-rwxr--r--	2025-06-03 08:49:51
smbspool	application/x-pie-executable	24.45 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbstatus	application/x-pie-executable	112.81 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
smbtar	text/x-shellscript	4.59 KB	root/root	-rwxr-xr-x	2023-07-18 08:14:54
smbtree	application/x-pie-executable	20.42 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
snice	application/x-pie-executable	28.8 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
snmpbulkget	application/x-pie-executable	12.48 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpbulkwalk	application/x-pie-executable	16.5 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpconf	text/x-perl	25.44 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:31
snmpdelta	application/x-pie-executable	24.6 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpdf	application/x-pie-executable	16.41 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpget	application/x-pie-executable	12.36 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpgetnext	application/x-pie-executable	12.36 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpinform	application/x-pie-executable	16.66 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpnetstat	application/x-pie-executable	71.36 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpping	application/x-pie-executable	20.51 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpps	application/x-pie-executable	20.53 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpset	application/x-pie-executable	16.36 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpstatus	application/x-pie-executable	17.25 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmptable	application/x-pie-executable	24.48 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmptest	application/x-pie-executable	16.27 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmptls	application/x-pie-executable	20.51 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmptop	application/x-pie-executable	20.53 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmptranslate	application/x-pie-executable	20.4 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmptrap	application/x-pie-executable	16.66 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpusm	application/x-pie-executable	40.61 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpvacm	application/x-pie-executable	33.48 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
snmpwalk	application/x-pie-executable	16.47 KB	root/root	-rwxr-xr-x	2024-05-23 09:15:36
socat	application/x-pie-executable	406.55 KB	root/root	-rwxr-xr-x	2021-10-08 03:43:20
soelim	application/x-pie-executable	42.55 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
sort	application/x-pie-executable	123.55 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sotruss	text/x-shellscript	4.18 KB	root/root	-rwxr-xr-x	2025-06-09 08:25:41
spamassassin	text/x-perl	29.39 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:53
spamc	application/x-pie-executable	50.15 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:59
spamd	text/x-perl	127.63 KB	root/root	-rwxr-xr-x	2022-04-18 10:39:53
spell	text/x-shellscript	122 B	root/root	-rwxr-xr-x	2022-04-18 03:10:51
spfd	text/x-perl	17.96 KB	root/root	-rw-r--r--	2020-06-03 11:21:49
spfd.perl-Mail-SPF	text/x-perl	17.96 KB	root/root	-rw-r--r--	2020-06-03 11:21:49
spfquery	text/x-script.python	4.5 KB	root/root	-rwxr-xr-x	2020-11-10 10:08:44
spfquery.perl-Mail-SPF	text/x-perl	22.45 KB	root/root	-rwxr-xr-x	2020-06-03 11:21:49
splain	text/x-perl	18.7 KB	root/root	-rwxr-xr-x	2023-05-18 09:36:25
split	application/x-pie-executable	58.13 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sprof	application/x-pie-executable	28.67 KB	root/root	-rwxr-xr-x	2025-06-09 08:31:29
sqlite3	application/x-pie-executable	1.28 MB	root/root	-rwxr-xr-x	2024-01-16 08:21:04
sscg	application/x-pie-executable	57.14 KB	root/root	-rwxr-xr-x	2023-04-02 05:28:10
ssh	application/x-pie-executable	757.54 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
ssh-add	application/x-pie-executable	346.13 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
ssh-agent	application/x-pie-executable	325.58 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
ssh-copy-id	text/x-shellscript	10.44 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:39
ssh-keygen	application/x-pie-executable	427.16 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
ssh-keyscan	application/x-pie-executable	428.57 KB	root/root	-rwxr-xr-x	2025-02-19 08:59:40
sshpass	application/x-pie-executable	20.48 KB	root/root	-rwxr-xr-x	2022-05-03 12:03:03
stat	application/x-pie-executable	86.23 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
statist	application/x-pie-executable	17.55 KB	root/root	-rwxr-xr-x	2019-07-23 09:19:31
stdbuf	application/x-pie-executable	49.58 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
strace	application/x-pie-executable	1.94 MB	root/root	-rwxr-xr-x	2025-01-28 01:32:17
strace-log-merge	text/x-shellscript	1.78 KB	root/root	-rwxr-xr-x	2021-02-16 08:00:00
stream	application/x-pie-executable	11.83 KB	root/root	-rwxr-xr-x	2025-04-01 01:15:58
strings	application/x-pie-executable	37.43 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
strip	application/x-pie-executable	240.09 KB	root/root	-rwxr-xr-x	2024-11-15 09:59:32
stty	application/x-pie-executable	77.68 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
stunnel	application/x-pie-executable	225.1 KB	root/root	-rwxr-xr-x	2024-09-24 02:21:09
su	application/x-pie-executable	48.98 KB	root/root	-rwsr-xr-x	2024-04-06 01:02:53
sudo		186.52 KB	root/root	---s--x--x	2024-02-14 02:13:50
sudoedit		186.52 KB	root/root	---s--x--x	2024-02-14 02:13:50
sudoreplay		115.2 KB	root/root	---x--x--x	2024-02-14 02:13:50
sum	application/x-pie-executable	45.61 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
sxpm	application/x-pie-executable	28.81 KB	root/root	-rwxr-xr-x	2024-03-30 01:53:16
sync	application/x-pie-executable	37.43 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
systemctl	application/x-pie-executable	218.45 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-analyze	application/x-pie-executable	1.55 MB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-ask-password	application/x-pie-executable	12.02 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-cat	application/x-pie-executable	16.03 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-cgls	application/x-pie-executable	16.44 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-cgtop	application/x-pie-executable	32.88 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-delta	application/x-pie-executable	24.45 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-detect-virt	application/x-pie-executable	11.88 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-escape	application/x-pie-executable	16.01 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-firstboot	application/x-pie-executable	36.98 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-hwdb	application/x-pie-executable	28.91 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-inhibit	application/x-pie-executable	16.03 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-machine-id-setup	application/x-pie-executable	24.75 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-mount	application/x-pie-executable	52.63 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-notify	application/x-pie-executable	16.03 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-path	application/x-pie-executable	16.02 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-resolve	application/x-pie-executable	195.74 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-run	application/x-pie-executable	48.94 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-socket-activate	application/x-pie-executable	24.77 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-stdio-bridge	application/x-pie-executable	16.02 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-sysusers	application/x-pie-executable	53.05 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-tmpfiles	application/x-pie-executable	73.29 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-tty-ask-password-agent	application/x-pie-executable	32.82 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
systemd-umount	application/x-pie-executable	52.63 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
tabs	application/x-pie-executable	16.55 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
tac	application/x-pie-executable	41.57 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
tail	application/x-pie-executable	74.2 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
tapestat	application/x-pie-executable	41.32 KB	root/root	-rwxr-xr-x	2024-07-03 09:57:26
tar	application/x-pie-executable	448.99 KB	root/root	-rwxr-xr-x	2025-06-11 02:11:24
taskset	application/x-pie-executable	37.25 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
tbl	application/x-pie-executable	154.61 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
tcamgr	application/x-pie-executable	25.13 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcamttest	application/x-pie-executable	21.16 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcatest	application/x-pie-executable	57.6 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcbmgr	application/x-pie-executable	29.1 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcbmttest	application/x-pie-executable	53.22 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcbtest	application/x-pie-executable	69.56 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcfmgr	application/x-pie-executable	25.09 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcfmttest	application/x-pie-executable	37.2 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcftest	application/x-pie-executable	45.18 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tchmgr	application/x-pie-executable	25.09 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tchmttest	application/x-pie-executable	49.22 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tchtest	application/x-pie-executable	57.53 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcptraceroute	text/x-shellscript	1.55 KB	root/root	-rwxr-xr-x	2025-03-11 07:45:53
tcsh	application/x-pie-executable	432.09 KB	root/root	-rwxr-xr-x	2022-04-18 05:03:39
tctmgr	application/x-pie-executable	37.09 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tctmttest	application/x-pie-executable	45.2 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcttest	application/x-pie-executable	57.19 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcucodec	application/x-pie-executable	37.08 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcumttest	application/x-pie-executable	25.16 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tcutest	application/x-pie-executable	73.17 KB	root/root	-rwxr-xr-x	2019-10-13 01:22:36
tee	application/x-pie-executable	41.55 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
telnet	application/x-pie-executable	104.88 KB	root/root	-rwxr-xr-x	2021-04-09 10:39:55
test	application/x-pie-executable	53.63 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
testparm	application/x-pie-executable	44.51 KB	root/root	-rwxr-xr-x	2025-06-03 08:50:03
tic	application/x-pie-executable	85.31 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
time	application/x-pie-executable	27.54 KB	root/root	-rwxr-xr-x	2019-10-11 03:23:33
timedatectl	application/x-pie-executable	36.96 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
timeout	application/x-pie-executable	41.93 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
tload	application/x-pie-executable	16.76 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
tmpwatch	application/x-pie-executable	35.47 KB	root/root	-rwxr-xr-x	2019-10-12 11:32:29
toe	application/x-pie-executable	16.45 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
top	application/x-pie-executable	121.7 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
touch	application/x-pie-executable	94.02 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
tput	application/x-pie-executable	24.8 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
tr	application/x-pie-executable	49.7 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
tracepath	application/x-pie-executable	20.44 KB	root/root	-rwxr-xr-x	2023-10-14 05:19:01
traceroute	application/x-pie-executable	70.97 KB	root/root	-rwxr-xr-x	2025-03-11 07:45:53
traceroute6	application/x-pie-executable	70.97 KB	root/root	-rwxr-xr-x	2025-03-11 07:45:53
tred	application/x-pie-executable	16.59 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
troff	application/x-pie-executable	805.02 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41
true	application/x-pie-executable	33.4 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
truncate	application/x-pie-executable	41.44 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
trust	application/x-pie-executable	219.55 KB	root/root	-rwxr-xr-x	2024-04-06 02:16:19
tset	application/x-pie-executable	24.76 KB	root/root	-rwxr-xr-x	2023-10-14 06:54:49
tsort	application/x-pie-executable	41.57 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
tty	application/x-pie-executable	33.39 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
twopi	application/x-pie-executable	12.26 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:16
type	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
type99	text/x-script.python	4.57 KB	root/root	-rwxr-xr-x	2020-11-10 10:08:44
tzselect	text/x-shellscript	15.01 KB	root/root	-rwxr-xr-x	2025-06-09 08:25:25
uconv	application/x-pie-executable	60.73 KB	root/root	-rwxr-xr-x	2020-03-20 07:32:35
ucs2any	application/x-pie-executable	24.41 KB	root/root	-rwxr-xr-x	2021-10-09 11:42:47
udevadm	application/x-pie-executable	424.59 KB	root/root	-rwxr-xr-x	2025-04-22 01:58:57
ul	application/x-pie-executable	20.58 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
ulimit	text/x-shellscript	30 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
umask	text/x-shellscript	29 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
umount	application/x-pie-executable	32.75 KB	root/root	-rwsr-xr-x	2024-04-06 01:02:53
unalias	text/x-shellscript	31 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
uname	application/x-pie-executable	37.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
uname26	application/x-pie-executable	20.76 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
unarj	text/x-shellscript	74 B	root/root	-rwxr-xr-x	2019-07-23 09:40:47
uncompress	application/x-pie-executable	25.37 KB	root/root	-rwxr-xr-x	2020-08-30 05:37:33
unexpand	application/x-pie-executable	45.68 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
unflatten	application/x-pie-executable	16.63 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:15
unfreeze	application/x-pie-executable	32.39 KB	root/root	-rwxr-xr-x	2019-07-23 09:19:31
unicode_start	text/x-shellscript	2.55 KB	root/root	-rwxr-xr-x	2023-10-14 08:59:57
unicode_stop	text/x-shellscript	363 B	root/root	-rwxr-xr-x	2023-10-14 08:59:56
uniq	application/x-pie-executable	49.72 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
unlink	application/x-pie-executable	33.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
unshare	application/x-pie-executable	24.92 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
unversioned-python	text/x-shellscript	157 B	root/root	-rwxr-xr-x	2024-12-05 01:10:18
unxz	application/x-pie-executable	82.09 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:34
unzip	application/x-pie-executable	201.88 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:12
unzipsfx	application/x-pie-executable	101.48 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:12
unzoo	application/x-executable	33.25 KB	root/root	-rwxr-xr-x	2020-10-28 07:35:52
update-ca-trust	text/x-shellscript	1.24 KB	root/root	-rwxr-xr-x	2024-08-21 07:16:41
update-gtk-immodules	text/x-shellscript	313 B	root/root	-rwxr-xr-x	2021-04-06 01:52:28
update-mime-database	application/x-pie-executable	57.22 KB	root/root	-rwxr-xr-x	2024-04-06 02:07:10
updatedb	application/x-pie-executable	53.84 KB	root/root	-rwxr-xr-x	2019-10-14 03:43:04
uptime	application/x-pie-executable	12.59 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
users	application/x-pie-executable	37.47 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
usleep	application/x-pie-executable	11.85 KB	root/root	-rwxr-xr-x	2022-10-08 11:08:06
utmpdump	application/x-pie-executable	28.66 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
uuclient	application/x-pie-executable	15.88 KB	root/root	-rwxr-xr-x	2025-06-03 02:06:30
uuidgen	application/x-pie-executable	16.37 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
uuidparse	application/x-pie-executable	37.13 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
vdir	application/x-pie-executable	139.97 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
vi	application/x-pie-executable	1.13 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
view	application/x-pie-executable	1.13 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
vim	application/x-pie-executable	2.93 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
vimdiff	application/x-pie-executable	2.93 MB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
vimdot	text/x-shellscript	1.06 KB	root/root	-rwxr-xr-x	2024-04-06 12:47:05
vimtutor	text/x-shellscript	2.07 KB	root/root	-rwxr-xr-x	2022-08-02 04:56:59
vlock	application/x-pie-executable	20.83 KB	root/root	-rwxr-xr-x	2023-10-14 09:01:01
vmstat	application/x-pie-executable	36.79 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
w	application/x-pie-executable	20.75 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
wait	text/x-shellscript	28 B	root/root	-rwxr-xr-x	2024-05-23 08:55:41
wall	application/x-pie-executable	33.05 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
watch	application/x-pie-executable	29.19 KB	root/root	-rwxr-xr-x	2023-10-14 08:31:02
watchgnupg	application/x-pie-executable	16.43 KB	root/root	-rwxr-xr-x	2022-09-13 10:15:05
wc	application/x-pie-executable	49.72 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
wdctl	application/x-pie-executable	36.98 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
wget	application/x-pie-executable	521.41 KB	root/root	-rwxr-xr-x	2024-08-13 10:22:56
whatis	application/x-pie-executable	54.04 KB	root/root	-rwxr-xr-x	2021-10-08 01:04:46
whereis	application/x-pie-executable	29.27 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
which	application/x-pie-executable	29.44 KB	root/root	-rwxr-xr-x	2023-10-15 02:50:46
whiptail	application/x-pie-executable	33.09 KB	root/root	-rwxr-xr-x	2020-06-01 02:11:18
who	application/x-pie-executable	53.68 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
whoami	application/x-pie-executable	33.41 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
word-list-compress	application/x-pie-executable	11.99 KB	root/root	-rwxr-xr-x	2022-04-18 03:10:53
write	application/x-pie-executable	20.62 KB	root/tty	-rwxr-sr-x	2024-04-06 01:02:53
wsrep_sst_backup	text/x-shellscript	2.39 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
wsrep_sst_common	text/plain	66.86 KB	root/root	-rw-r--r--	2025-04-27 06:16:05
wsrep_sst_mariabackup	text/x-shellscript	49.47 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
wsrep_sst_mysqldump	text/x-shellscript	8.1 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
wsrep_sst_rsync	text/x-shellscript	29.72 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
wsrep_sst_rsync_wan	text/x-shellscript	29.72 KB	root/root	-rwxr-xr-x	2025-04-27 06:16:05
x86_64	application/x-pie-executable	20.76 KB	root/root	-rwxr-xr-x	2024-04-06 01:02:53
x86_64-redhat-linux-c++	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:33
x86_64-redhat-linux-g++	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:33
x86_64-redhat-linux-gcc	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
x86_64-redhat-linux-gcc-8	application/x-pie-executable	1.21 MB	root/root	-rwxr-xr-x	2025-03-31 10:38:36
x86_64-redhat-linux-gnu-pkg-config	text/x-shellscript	424 B	root/root	-rwxr-xr-x	2019-10-13 06:57:31
xargs	application/x-pie-executable	74.11 KB	root/root	-rwxr-xr-x	2024-09-24 02:19:34
xgamma	application/x-pie-executable	17.08 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xhost	application/x-pie-executable	17.12 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xinput	application/x-pie-executable	63.61 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xkill	application/x-pie-executable	17.1 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xml2-config	text/x-shellscript	1.71 KB	root/root	-rwxr-xr-x	2017-07-23 05:10:06
xmlcatalog	application/x-pie-executable	20.38 KB	root/root	-rwxr-xr-x	2025-06-12 01:41:21
xmllint	application/x-pie-executable	73.37 KB	root/root	-rwxr-xr-x	2025-06-12 01:41:21
xmlwf	application/x-pie-executable	32.96 KB	root/root	-rwxr-xr-x	2025-04-15 07:58:56
xmodmap	application/x-pie-executable	39.98 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xorg-x11-fonts-update-dirs	text/x-shellscript	1.29 KB	root/root	-rwxr--r--	2021-10-09 11:42:46
xrandr	application/x-pie-executable	65.46 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xrdb	application/x-pie-executable	33.98 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xrefresh	application/x-pie-executable	17.94 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xset	application/x-pie-executable	37.2 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xsetpointer	application/x-pie-executable	13.05 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xsetroot	application/x-pie-executable	21.44 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xslt-config	text/x-shellscript	2.36 KB	root/root	-rwxr-xr-x	2015-05-10 02:11:30
xsltproc	application/x-pie-executable	28.47 KB	root/root	-rwxr-xr-x	2025-06-09 03:03:50
xstdcmap	application/x-pie-executable	17.68 KB	root/root	-rwxr-xr-x	2019-10-15 01:08:41
xsubpp	text/x-perl	4.96 KB	root/root	-rwxr-xr-x	2019-10-13 08:58:35
xxd	application/x-pie-executable	20.52 KB	root/root	-rwxr-xr-x	2022-08-02 04:57:02
xz	application/x-pie-executable	82.09 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:34
xzcat	application/x-pie-executable	82.09 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:34
xzcmp	text/x-shellscript	6.48 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
xzdec	application/x-pie-executable	16.48 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:34
xzdiff	text/x-shellscript	6.48 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
xzegrep	text/x-shellscript	5.76 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
xzfgrep	text/x-shellscript	5.76 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
xzgrep	text/x-shellscript	5.76 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
xzless	text/x-shellscript	1.76 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
xzmore	text/x-shellscript	2.11 KB	root/root	-rwxr-xr-x	2022-06-14 01:03:30
yat2m	application/x-pie-executable	33.34 KB	root/root	-rwxr-xr-x	2019-10-12 12:20:46
yes	application/x-pie-executable	33.45 KB	root/root	-rwxr-xr-x	2023-04-01 08:44:39
ypdomainname	application/x-pie-executable	21.16 KB	root/root	-rwxr-xr-x	2019-10-11 01:06:51
yum	text/x-script.python	2.05 KB	root/root	-rwxr-xr-x	2025-03-11 09:47:56
zcat	text/x-shellscript	1.94 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zcmp	text/x-shellscript	1.64 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zdiff	text/x-shellscript	5.74 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zegrep	text/x-shellscript	29 B	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zfgrep	text/x-shellscript	29 B	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zforce	text/x-shellscript	2.03 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zgrep	text/x-shellscript	7.4 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zip	application/x-pie-executable	229 KB	root/root	-rwxr-xr-x	2019-10-11 01:11:04
zipcloak	application/x-pie-executable	102.91 KB	root/root	-rwxr-xr-x	2019-10-11 01:11:04
zipdetails	text/x-perl	49.39 KB	root/root	-rwxr-xr-x	2019-10-13 09:48:20
zipgrep	text/x-shellscript	2.88 KB	root/root	-rwxr-xr-x	2008-10-10 05:40:36
zipinfo	application/x-pie-executable	201.88 KB	root/root	-rwxr-xr-x	2025-06-03 02:10:12
zipnote	application/x-pie-executable	97.76 KB	root/root	-rwxr-xr-x	2019-10-11 01:11:04
zipsplit	application/x-pie-executable	97.76 KB	root/root	-rwxr-xr-x	2019-10-11 01:11:04
zless	text/x-shellscript	2.15 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zmore	text/x-shellscript	1.8 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
znew	text/x-shellscript	4.45 KB	root/root	-rwxr-xr-x	2022-04-27 05:49:28
zsoelim	application/x-pie-executable	42.55 KB	root/root	-rwxr-xr-x	2019-10-13 02:29:41