You will need to bypass the keys .. I herd once this is done ..its on. This bot is very fast from what I seen . IF anyone here hack it please post the fix.
Code:
#!/usr/bin/env perl
#line 2 "/usr/bin/par.pl"
eval 'exec /usr/bin/env perl -S $0 ${1+"$@"}'
if 0; # not running under some shell
eval 'exec /usr/bin/env perl -S $0 ${1+"$@"}'
if 0; # not running under some shell
package __par_pl;
# --- This script must not use any modules at compile time ---
# use strict;
#line 161
my ($par_temp, $progname, @tmpfile);
END { if ($ENV{PAR_CLEAN}) {
require File::Temp;
require File::Basename;
require File::Spec;
my $topdir = File::Basename::dirname($par_temp);
outs(qq{Removing files in "$par_temp"});
File::Find::finddepth(sub { ( -d ) ? rmdir : unlink }, $par_temp);
rmdir $par_temp;
# Don't remove topdir because this causes a race with other apps
# that are trying to start.
if (-d $par_temp && $^O ne 'MSWin32') {
# Something went wrong unlinking the temporary directory. This
# typically happens on platforms that disallow unlinking shared
# libraries and executables that are in use. Unlink with a background
# shell command so the files are no longer in use by this process.
# Don't do anything on Windows because our parent process will
# take care of cleaning things up.
my $tmp = new File::Temp(
TEMPLATE => 'tmpXXXXX',
DIR => File::Basename::dirname($topdir),
SUFFIX => '.cmd',
UNLINK => 0,
);
print $tmp "#!/bin/sh
x=1; while [ \$x -lt 10 ]; do
rm -rf '$par_temp'
if [ \! -d '$par_temp' ]; then
break
fi
sleep 1
x=`expr \$x + 1`
done
rm '" . $tmp->filename . "'
";
chmod 0700,$tmp->filename;
my $cmd = $tmp->filename . ' >/dev/null 2>&1 &';
close $tmp;
system($cmd);
outs(qq(Spawned background process to perform cleanup: )
. $tmp->filename);
}
} }
BEGIN {
Internals::PAR::BOOT() if defined &Internals::PAR::BOOT;
eval {
_par_init_env();
if (exists $ENV{PAR_ARGV_0} and $ENV{PAR_ARGV_0} ) {
@ARGV = map $ENV{"PAR_ARGV_$_"}, (1 .. $ENV{PAR_ARGC} - 1);
$0 = $ENV{PAR_ARGV_0};
}
else {
for (keys %ENV) {
delete $ENV{$_} if /^PAR_ARGV_/;
}
}
my $quiet = !$ENV{PAR_DEBUG};
# fix $progname if invoked from PATH
my %Config = (
path_sep => ($^O =~ /^MSWin/ ? ';' : ':'),
_exe => ($^O =~ /^(?:MSWin|OS2|cygwin)/ ? '.exe' : ''),
_delim => ($^O =~ /^MSWin|OS2/ ? '\\' : '/'),
);
_set_progname();
_set_par_temp();
# Magic string checking and extracting bundled modules {{{
my ($start_pos, $data_pos);
{
local $SIG{__WARN__} = sub {};
# Check file type, get start of data section {{{
open _FH, '<', $progname or last;
binmode(_FH);
my $buf;
seek _FH, -8, 2;
read _FH, $buf, 8;
last unless $buf eq "\nPAR.pm\n";
seek _FH, -12, 2;
read _FH, $buf, 4;
seek _FH, -12 - unpack("N", $buf), 2;
read _FH, $buf, 4;
$data_pos = (tell _FH) - 4;
# }}}
# Extracting each file into memory {{{
my %require_list;
while ($buf eq "FILE") {
read _FH, $buf, 4;
read _FH, $buf, unpack("N", $buf);
my $fullname = $buf;
outs(qq(Unpacking file "$fullname"...));
my $crc = ( $fullname =~ s|^([a-f\d]{8})/|| ) ? $1 : undef;
my ($basename, $ext) = ($buf =~ m|(?:.*/)?(.*)(\..*)|);
read _FH, $buf, 4;
read _FH, $buf, unpack("N", $buf);
if (defined($ext) and $ext !~ /\.(?:pm|pl|ix|al)$/i) {
my ($out, $filename) = _tempfile($ext, $crc);
if ($out) {
binmode($out);
print $out $buf;
close $out;
chmod 0755, $filename;
}
$PAR::Heavy::FullCache{$fullname} = $filename;
$PAR::Heavy::FullCache{$filename} = $fullname;
}
elsif ( $fullname =~ m|^/?shlib/| and defined $ENV{PAR_TEMP} ) {
# should be moved to _tempfile()
my $filename = "$ENV{PAR_TEMP}/$basename$ext";
outs("SHLIB: $filename\n");
open my $out, '>', $filename or die $!;
binmode($out);
print $out $buf;
close $out;
}
else {
$require_list{$fullname} =
$PAR::Heavy::ModuleCache{$fullname} = {
buf => $buf,
crc => $crc,
name => $fullname,
};
}
read _FH, $buf, 4;
}
# }}}
local @INC = (sub {
my ($self, $module) = @_;
return if ref $module or !$module;
my $filename = delete $require_list{$module} || do {
my $key;
foreach (keys %require_list) {
next unless /\Q$module\E$/;
$key = $_; last;
}
delete $require_list{$key} if defined($key);
} or return;
$INC{$module} = "/loader/$filename/$module";
if ($ENV{PAR_CLEAN} and defined(&IO::File::new)) {
my $fh = IO::File->new_tmpfile or die $!;
binmode($fh);
print $fh $filename->{buf};
seek($fh, 0, 0);
return $fh;
}
else {
my ($out, $name) = _tempfile('.pm', $filename->{crc});
if ($out) {
binmode($out);
print $out $filename->{buf};
close $out;
}
open my $fh, '<', $name or die $!;
binmode($fh);
return $fh;
}
die "Bootstrapping failed: cannot find $module!\n";
}, @INC);
# Now load all bundled files {{{
# initialize shared object processing
require XSLoader;
require PAR::Heavy;
require Carp::Heavy;
require Exporter::Heavy;
PAR::Heavy::_init_dynaloader();
# now let's try getting helper modules from within
require IO::File;
# load rest of the group in
while (my $filename = (sort keys %require_list)[0]) {
#local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
unless ($INC{$filename} or $filename =~ /BSDPAN/) {
# require modules, do other executable files
if ($filename =~ /\.pmc?$/i) {
require $filename;
}
else {
# Skip ActiveState's sitecustomize.pl file:
do $filename unless $filename =~ /sitecustomize\.pl$/;
}
}
delete $require_list{$filename};
}
# }}}
last unless $buf eq "PK\003\004";
$start_pos = (tell _FH) - 4;
}
# }}}
# Argument processing {{{
my @par_args;
my ($out, $bundle, $logfh, $cache_name);
delete $ENV{PAR_APP_REUSE}; # sanitize (REUSE may be a security problem)
$quiet = 0 unless $ENV{PAR_DEBUG};
# Don't swallow arguments for compiled executables without --par-options
if (!$start_pos or ($ARGV[0] eq '--par-options' && shift)) {
my %dist_cmd = qw(
p blib_to_par
i install_par
u uninstall_par
s sign_par
v verify_par
);
# if the app is invoked as "appname --par-options --reuse PROGRAM @PROG_ARGV",
# use the app to run the given perl code instead of anything from the
# app itself (but still set up the normal app environment and @INC)
if (@ARGV and $ARGV[0] eq '--reuse') {
shift @ARGV;
$ENV{PAR_APP_REUSE} = shift @ARGV;
}
else { # normal parl behaviour
my @add_to_inc;
while (@ARGV) {
$ARGV[0] =~ /^-([AIMOBLbqpiusTv])(.*)/ or last;
if ($1 eq 'I') {
push @add_to_inc, $2;
}
elsif ($1 eq 'M') {
eval "use $2";
}
elsif ($1 eq 'A') {
unshift @par_args, $2;
}
elsif ($1 eq 'O') {
$out = $2;
}
elsif ($1 eq 'b') {
$bundle = 'site';
}
elsif ($1 eq 'B') {
$bundle = 'all';
}
elsif ($1 eq 'q') {
$quiet = 1;
}
elsif ($1 eq 'L') {
open $logfh, ">>", $2 or die "XXX: Cannot open log: $!";
}
elsif ($1 eq 'T') {
$cache_name = $2;
}
shift(@ARGV);
if (my $cmd = $dist_cmd{$1}) {
delete $ENV{'PAR_TEMP'};
init_inc();
require PAR::Dist;
&{"PAR::Dist::$cmd"}() unless @ARGV;
&{"PAR::Dist::$cmd"}($_) for @ARGV;
exit;
}
}
unshift @INC, @add_to_inc;
}
}
# XXX -- add --par-debug support!
# }}}
# Output mode (-O) handling {{{
if ($out) {
{
#local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
require IO::File;
require Archive::Zip;
}
my $par = shift(@ARGV);
my $zip;
if (defined $par) {
open my $fh, '<', $par or die "Cannot find '$par': $!";
binmode($fh);
bless($fh, 'IO::File');
$zip = Archive::Zip->new;
( $zip->readFromFileHandle($fh, $par) == Archive::Zip::AZ_OK() )
or die "Read '$par' error: $!";
}
my %env = do {
if ($zip and my $meta = $zip->contents('META.yml')) {
$meta =~ s/.*^par:$//ms;
$meta =~ s/^\S.*//ms;
$meta =~ /^ ([^:]+): (.+)$/mg;
}
};
# Open input and output files {{{
local $/ = \4;
if (defined $par) {
open PAR, '<', $par or die "$!: $par";
binmode(PAR);
die "$par is not a PAR file" unless <PAR> eq "PK\003\004";
}
CreatePath($out) ;
my $fh = IO::File->new(
$out,
IO::File::O_CREAT() | IO::File::O_WRONLY() | IO::File::O_TRUNC(),
0777,
) or die $!;
binmode($fh);
$/ = (defined $data_pos) ? \$data_pos : undef;
seek _FH, 0, 0;
my $loader = scalar <_FH>;
if (!$ENV{PAR_VERBATIM} and $loader =~ /^(?:#!|\@rem)/) {
require PAR::Filter::PodStrip;
PAR::Filter::PodStrip->new->apply(\$loader, $0)
}
foreach my $key (sort keys %env) {
my $val = $env{$key} or next;
$val = eval $val if $val =~ /^['"]/;
my $magic = "__ENV_PAR_" . uc($key) . "__";
my $set = "PAR_" . uc($key) . "=$val";
$loader =~ s{$magic( +)}{
$magic . $set . (' ' x (length($1) - length($set)))
}eg;
}
$fh->print($loader);
$/ = undef;
# }}}
# Write bundled modules {{{
if ($bundle) {
require PAR::Heavy;
PAR::Heavy::_init_dynaloader();
init_inc();
require_modules();
my @inc = sort {
length($b) <=> length($a)
} grep {
!/BSDPAN/
} grep {
($bundle ne 'site') or
($_ ne $Config::Config{archlibexp} and
$_ ne $Config::Config{privlibexp});
} @INC;
# File exists test added to fix RT #41790:
# Funny, non-existing entry in _<....auto/Compress/Raw/Zlib/autosplit.ix.
# This is a band-aid fix with no deeper grasp of the issue.
# Somebody please go through the pain of understanding what's happening,
# I failed. -- Steffen
my %files;
/^_<(.+)$/ and -e $1 and $files{$1}++ for keys %::;
$files{$_}++ for values %INC;
my $lib_ext = $Config::Config{lib_ext};
my %written;
foreach (sort keys %files) {
my ($name, $file);
foreach my $dir (@inc) {
if ($name = $PAR::Heavy::FullCache{$_}) {
$file = $_;
last;
}
elsif (/^(\Q$dir\E\/(.*[^Cc]))\Z/i) {
($file, $name) = ($1, $2);
last;
}
elsif (m!^/loader/[^/]+/(.*[^Cc])\Z!) {
if (my $ref = $PAR::Heavy::ModuleCache{$1}) {
($file, $name) = ($ref, $1);
last;
}
elsif (-f "$dir/$1") {
($file, $name) = ("$dir/$1", $1);
last;
}
}
}
next unless defined $name and not $written{$name}++;
next if !ref($file) and $file =~ /\.\Q$lib_ext\E$/;
outs( join "",
qq(Packing "), ref $file ? $file->{name} : $file,
qq("...)
);
my $content;
if (ref($file)) {
$content = $file->{buf};
}
else {
open FILE, '<', $file or die "Can't open $file: $!";
binmode(FILE);
$content = <FILE>;
close FILE;
PAR::Filter::PodStrip->new->apply(\$content, $file)
if !$ENV{PAR_VERBATIM} and $name =~ /\.(?:pm|ix|al)$/i;
PAR::Filter::PatchContent->new->apply(\$content, $file, $name);
}
outs(qq(Written as "$name"));
$fh->print("FILE");
$fh->print(pack('N', length($name) + 9));
$fh->print(sprintf(
"%08x/%s", Archive::Zip::computeCRC32($content), $name
));
$fh->print(pack('N', length($content)));
$fh->print($content);
}
}
# }}}
# Now write out the PAR and magic strings {{{
$zip->writeToFileHandle($fh) if $zip;
$cache_name = substr $cache_name, 0, 40;
if (!$cache_name and my $mtime = (stat($out))[9]) {
my $ctx = eval { require Digest::SHA; Digest::SHA->new(1) }
|| eval { require Digest::SHA1; Digest::SHA1->new }
|| eval { require Digest::MD5; Digest::MD5->new };
# Workaround for bug in Digest::SHA 5.38 and 5.39
my $sha_version = eval { $Digest::SHA::VERSION } || 0;
if ($sha_version eq '5.38' or $sha_version eq '5.39') {
$ctx->addfile($out, "b") if ($ctx);
}
else {
if ($ctx and open(my $fh, "<$out")) {
binmode($fh);
$ctx->addfile($fh);
close($fh);
}
}
$cache_name = $ctx ? $ctx->hexdigest : $mtime;
}
$cache_name .= "\0" x (41 - length $cache_name);
$cache_name .= "CACHE";
$fh->print($cache_name);
$fh->print(pack('N', $fh->tell - length($loader)));
$fh->print("\nPAR.pm\n");
$fh->close;
chmod 0755, $out;
# }}}
exit;
}
# }}}
# Prepare $progname into PAR file cache {{{
{
last unless defined $start_pos;
_fix_progname();
# Now load the PAR file and put it into PAR::LibCache {{{
require PAR;
PAR::Heavy::_init_dynaloader();
{
#local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
require File::Find;
require Archive::Zip;
}
my $zip = Archive::Zip->new;
my $fh = IO::File->new;
$fh->fdopen(fileno(_FH), 'r') or die "$!: $@";
$zip->readFromFileHandle($fh, $progname) == Archive::Zip::AZ_OK() or die "$!: $@";
push @PAR::LibCache, $zip;
$PAR::LibCache{$progname} = $zip;
$quiet = !$ENV{PAR_DEBUG};
outs(qq(\$ENV{PAR_TEMP} = "$ENV{PAR_TEMP}"));
if (defined $ENV{PAR_TEMP}) { # should be set at this point!
foreach my $member ( $zip->members ) {
next if $member->isDirectory;
my $member_name = $member->fileName;
next unless $member_name =~ m{
^
/?shlib/
(?:$Config::Config{version}/)?
(?:$Config::Config{archname}/)?
([^/]+)
$
}x;
my $extract_name = $1;
my $dest_name = File::Spec->catfile($ENV{PAR_TEMP}, $extract_name);
if (-f $dest_name && -s _ == $member->uncompressedSize()) {
outs(qq(Skipping "$member_name" since it already exists at "$dest_name"));
} else {
outs(qq(Extracting "$member_name" to "$dest_name"));
$member->extractToFileNamed($dest_name);
chmod(0555, $dest_name) if $^O eq "hpux";
}
}
}
# }}}
}
# }}}
# If there's no main.pl to run, show usage {{{
unless ($PAR::LibCache{$progname}) {
die << "." unless @ARGV;
Usage: $0 [ -Alib.par ] [ -Idir ] [ -Mmodule ] [ src.par ] [ program.pl ]
$0 [ -B|-b ] [-Ooutfile] src.par
.
$ENV{PAR_PROGNAME} = $progname = $0 = shift(@ARGV);
}
# }}}
sub CreatePath {
my ($name) = @_;
require File::Basename;
my ($basename, $path, $ext) = File::Basename::fileparse($name, ('\..*'));
require File::Path;
File::Path::mkpath($path) unless(-e $path); # mkpath dies with error
}
sub require_modules {
#local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
require lib;
require DynaLoader;
require integer;
require strict;
require warnings;
require vars;
require Carp;
require Carp::Heavy;
require Errno;
require Exporter::Heavy;
require Exporter;
require Fcntl;
require File::Temp;
require File::Spec;
require XSLoader;
require Config;
require IO::Handle;
require IO::File;
require Compress::Zlib;
require Archive::Zip;
require PAR;
require PAR::Heavy;
require PAR::Dist;
require PAR::Filter::PodStrip;
require PAR::Filter::PatchContent;
require attributes;
eval { require Cwd };
eval { require Win32 };
eval { require Scalar::Util };
eval { require Archive::Unzip::Burst };
eval { require Tie::Hash::NamedCapture };
eval { require PerlIO; require PerlIO::scalar };
}
# The C version of this code appears in myldr/mktmpdir.c
# This code also lives in PAR::SetupTemp as set_par_temp_env!
sub _set_par_temp {
if (defined $ENV{PAR_TEMP} and $ENV{PAR_TEMP} =~ /(.+)/) {
$par_temp = $1;
return;
}
foreach my $path (
(map $ENV{$_}, qw( PAR_TMPDIR TMPDIR TEMPDIR TEMP TMP )),
qw( C:\\TEMP /tmp . )
) {
next unless defined $path and -d $path and -w $path;
my $username;
my $pwuid;
# does not work everywhere:
eval {($pwuid) = getpwuid($>) if defined $>;};
if ( defined(&Win32::LoginName) ) {
$username = &Win32::LoginName;
}
elsif (defined $pwuid) {
$username = $pwuid;
}
else {
$username = $ENV{USERNAME} || $ENV{USER} || 'SYSTEM';
}
$username =~ s/\W/_/g;
my $stmpdir = "$path$Config{_delim}par-$username";
mkdir $stmpdir, 0755;
if (!$ENV{PAR_CLEAN} and my $mtime = (stat($progname))[9]) {
open (my $fh, "<". $progname);
seek $fh, -18, 2;
sysread $fh, my $buf, 6;
if ($buf eq "\0CACHE") {
seek $fh, -58, 2;
sysread $fh, $buf, 41;
$buf =~ s/\0//g;
$stmpdir .= "$Config{_delim}cache-" . $buf;
}
else {
my $ctx = eval { require Digest::SHA; Digest::SHA->new(1) }
|| eval { require Digest::SHA1; Digest::SHA1->new }
|| eval { require Digest::MD5; Digest::MD5->new };
# Workaround for bug in Digest::SHA 5.38 and 5.39
my $sha_version = eval { $Digest::SHA::VERSION } || 0;
if ($sha_version eq '5.38' or $sha_version eq '5.39') {
$ctx->addfile($progname, "b") if ($ctx);
}
else {
if ($ctx and open(my $fh, "<$progname")) {
binmode($fh);
$ctx->addfile($fh);
close($fh);
}
}
$stmpdir .= "$Config{_delim}cache-" . ( $ctx ? $ctx->hexdigest : $mtime );
}
close($fh);
}
else {
$ENV{PAR_CLEAN} = 1;
$stmpdir .= "$Config{_delim}temp-$$";
}
$ENV{PAR_TEMP} = $stmpdir;
mkdir $stmpdir, 0755;
last;
}
$par_temp = $1 if $ENV{PAR_TEMP} and $ENV{PAR_TEMP} =~ /(.+)/;
}
sub _tempfile {
my ($ext, $crc) = @_;
my ($fh, $filename);
$filename = "$par_temp/$crc$ext";
if ($ENV{PAR_CLEAN}) {
unlink $filename if -e $filename;
push @tmpfile, $filename;
}
else {
return (undef, $filename) if (-r $filename);
}
open $fh, '>', $filename or die $!;
binmode($fh);
return($fh, $filename);
}
# same code lives in PAR::SetupProgname::set_progname
sub _set_progname {
if (defined $ENV{PAR_PROGNAME} and $ENV{PAR_PROGNAME} =~ /(.+)/) {
$progname = $1;
}
$progname ||= $0;
if ($ENV{PAR_TEMP} and index($progname, $ENV{PAR_TEMP}) >= 0) {
$progname = substr($progname, rindex($progname, $Config{_delim}) + 1);
}
if (!$ENV{PAR_PROGNAME} or index($progname, $Config{_delim}) >= 0) {
if (open my $fh, '<', $progname) {
return if -s $fh;
}
if (-s "$progname$Config{_exe}") {
$progname .= $Config{_exe};
return;
}
}
foreach my $dir (split /\Q$Config{path_sep}\E/, $ENV{PATH}) {
next if exists $ENV{PAR_TEMP} and $dir eq $ENV{PAR_TEMP};
$dir =~ s/\Q$Config{_delim}\E$//;
(($progname = "$dir$Config{_delim}$progname$Config{_exe}"), last)
if -s "$dir$Config{_delim}$progname$Config{_exe}";
(($progname = "$dir$Config{_delim}$progname"), last)
if -s "$dir$Config{_delim}$progname";
}
}
sub _fix_progname {
$0 = $progname ||= $ENV{PAR_PROGNAME};
if (index($progname, $Config{_delim}) < 0) {
$progname = ".$Config{_delim}$progname";
}
# XXX - hack to make PWD work
my $pwd = (defined &Cwd::getcwd) ? Cwd::getcwd()
: ((defined &Win32::GetCwd) ? Win32::GetCwd() : `pwd`);
chomp($pwd);
$progname =~ s/^(?=\.\.?\Q$Config{_delim}\E)/$pwd$Config{_delim}/;
$ENV{PAR_PROGNAME} = $progname;
}
sub _par_init_env {
if ( $ENV{PAR_INITIALIZED}++ == 1 ) {
return;
} else {
$ENV{PAR_INITIALIZED} = 2;
}
for (qw( SPAWNED TEMP CLEAN DEBUG CACHE PROGNAME ARGC ARGV_0 ) ) {
delete $ENV{'PAR_'.$_};
}
for (qw/ TMPDIR TEMP CLEAN DEBUG /) {
$ENV{'PAR_'.$_} = $ENV{'PAR_GLOBAL_'.$_} if exists $ENV{'PAR_GLOBAL_'.$_};
}
my $par_clean = "__ENV_PAR_CLEAN__ ";
if ($ENV{PAR_TEMP}) {
delete $ENV{PAR_CLEAN};
}
elsif (!exists $ENV{PAR_GLOBAL_CLEAN}) {
my $value = substr($par_clean, 12 + length("CLEAN"));
$ENV{PAR_CLEAN} = $1 if $value =~ /^PAR_CLEAN=(\S+)/;
}
}
sub outs {
return if $quiet;
if ($logfh) {
print $logfh "@_\n";
}
else {
print "@_\n";
}
}
sub init_inc {
require Config;
push @INC, grep defined, map $Config::Config{$_}, qw(
archlibexp privlibexp sitearchexp sitelibexp
vendorarchexp vendorlibexp
);
}
########################################################################
# The main package for script execution
package main;
require PAR;
unshift @INC, \&PAR::find_par;
PAR->import(@par_args);
die qq(par.pl: Can't open perl script "$progname": No such file or directory\n)
unless -e $progname;
do $progname;
CORE::exit($1) if ($@ =~/^_TK_EXIT_\((\d+)\)/);
die $@ if $@;
};
$::__ERROR = $@ if $@;
}
CORE::exit($1) if ($::__ERROR =~/^_TK_EXIT_\((\d+)\)/);
die $::__ERROR if $::__ERROR;
1;
#line 1014
__END__
PK
here is the file needs fuzzing with
Bump: Here is a bit of the FTP/folder uploader..
Code:
Part of the "FTP to Tracker" feature for uploader is option to add folders to uploader even if they were not downloaded from other tracker (and added to database before).
This is new and some function names could change a lot. And this is considered not so stable at the moment. :)
Feature is available from revision >133.
To use it, function add_* must be added to your include/upload_*.pm file. (Replace * with your upload tracker code.)
Folder/file you are trying to add must be located in your download_dir.
Passing the folder to the uploader can be done using announce-helper (tuper.sh). Do it by: ./tuper.sh add category folder-name optional-upload-tracker
For example: ./tuper.sh "TV-EN" "David.Attenborough.Frozen.Planet.S01E04.720p.HDTV.x264-FTP" xxx
(To see what announce-helper is sending to tuper-client, view announce-helper.pl)
Here is sample add_xxx function:
(I know, it is a bit messy at the moment, it will get better once some feedback is generated.)
sub add_xxx {
my $category_name=shift;
my $directory=shift;
my $config=shift;
my $to_tracker="xxx";
my $directory_path=$config->{paths}->{download_dir}.$directory;
#################################
# Loading ClientFunctions class that has useful client functions
my $r=ClientFunctions->new('upload', $to_tracker, $config);
#################################
# Checking if folder exists in downloads directory
my $notsingle=0;
if(-d $directory_path){
$r->err("Found directory $directory to add");
$notsingle=1;
}elsif(-d $directory_path){
$r->err("Found single file $directory to add");
}else{
$r->err("Found no files to add, aborting!", "red"); return 0;
}
#################################
# Look for NFO
my $nfo="";
if($notsingle){
$r->err("Looking for NFO file");
my $upl_data_dir = $directory_path;
my $new_nfo="";
opendir(DIR, $upl_data_dir);
my @files = readdir(DIR);
for my $file (@files)
{
$file eq '.' and next;
$file eq '..' and next;
if( $file =~ /\.nfo$/i ){
$new_nfo=$upl_data_dir.'/'.$file;
$r->err("NFO file found: ".$new_nfo);
last;
}
}
if($new_nfo eq ""){
$nfo=$config->{tuper}->{no_descr_txt};
$r->err("Failed to find original NFO...");
}else{
if($nfo=$r->read_file($new_nfo)){
$r->err("Succeeded finding original NFO...");
}else{
$r->err("Found NFO file but failed to read it...");
}
}
}else{
$nfo=$config->{tuper}->{no_descr_txt};
}
my $description=$nfo;
#################################
# Set up name
my $name=$directory;
my $filename=$directory;
#################################
# Create torrent
my $torzname=$config->{paths}->{temp_dir}.$filename.".torrent";
my $anauns="http://example.com";
if(defined $config->{cookies}->{"announce_".$to_tracker}){
$anauns=$config->{cookies}->{"announce_".$to_tracker};
}
if(-f $torzname){
@argz=($torzname);
system "rm", @argz;
}
# Checking path size
my $size=$r->path_size($directory_path);
# Picking piece size for mktorrent
my $piece_size=$r->mktorrent_piece_size($size);
# Building torrent
@argz=('-p', '-v', '-l', $piece_size, '-a', $anauns, '-o', $torzname, $directory_path);
$r->err("mktorrent ".join(' ', @argz));
system "mktorrent", @argz;
if(not -f $torzname){
$r->err("Can't find the new torrent file, aborting."); return 0;
}
$r->err("Finished making torrent...");
#################################
# Getting info hash to add to the database
my $torrent_data=$r->read_file($torzname);
my $torrent_info=$r->process_torrent_data($torrent_data);
if(not $torrent_info->{'hash'}){ $r->err('Failed to get info hash. Is the torrent broken?'); return 0; }
my $down_hash=lc($torrent_info->{'hash'});
###################################
# Writing temp files
# Write NFO file
my $nfo_file=$config->{paths}->{temp_dir}.$filename.".nfo";
if($r->write_file('nfo', $nfo_file, $nfo)==0){ return 0; }
# Wrtie description file
my $descr_file=$config->{paths}->{temp_dir}.$filename.".txt";
if($r->write_file('description', $descr_file, $description)==0){ return 0; }
my $torr_file=$torzname;
my $target_cat_name=$category_name;
my $category_id=0;
eval " \$category_id = &cat_ftp_srv1_".$to_tracker."(\$target_cat_name); ";
if($category_id==0)
{ $r->err("Failed to find target tracker ($to_tracker) category ID for source tracker ($source) category name '$target_cat_name'.\nResponse was: $category_id", 'red'); return 0; }
$r->err("Category ID for $target_cat_name on $to_tracker => $category_id");
my $category=$category_id;
my %retvals=(
"name" => $name,
"descr" => $description,
"filename" => $filename,
"category" => $category,
"nfo_file" => $nfo_file,
"descr_file" => $descr_file,
"torrent_data" => $torrent,
"down_hash" => $down_hash,
);
return \%retvals;
}
And in your category conversion file (upload_*.config.pm) create the conversion function with all the categories that are there:
sub cat_ftp_srv1_xxx{
my $veids=shift;
my %cat=(
"0-Day" => 5,
"DVDR-DE" => 20,
"Games-PS2" => 13,
);
return &JhUp::find_hash_value(0, $veids, \%cat);
}
This is just temporary but to wrap it all up to auto upload from FTP server, create ftp-wrapper.sh:
#!/bin/sh
[ $# -lt 3 ] && { echo "Usage: $0 [add/aadd] [category] [name]" ; exit 1; }
cd /home/tup/downloads/ &&
lftp -u "username,password" -p 21 -e "cd $2 && mirror $3; quit" sample.com
cd /home/tup/tuper/
./tuper.sh $1 $2 $3
Edit it as needed. In this case it assumes that directories in root are named after categories.
|