use strict;

#! /usr/bin/perl

use strict;
use Cwd;
use POSIX qw(tmpnam); # ... needed (this may not work on Windows).
use LWP; # For the http request and package downloading...
use File::Copy qw(copy);
use File::Basename qw(dirname basename);
use File::Path qw(rmtree mkpath);
use FileHandle; # Use saner OO style instead of IO style for print function.
use Getopt::Long 2.01;
use Fcntl;

use FindBin;
use lib "$FindBin::RealBin/../lib/perl5";
use lib "/tmp/c";

use RDB qw(RDB_parse_array RDB_parse_string RDB_splice_data);
use INF qw(read_inf inf_get_key inf_get_keys inf_has_key);
use inf_nt qw(parse_inf_nt);
use imp_gpg;

########################################################################
# #### Start of file scoped variables.

# Where to install packages to.
my $base_dir = undef; # look in cd_temp()

# Where to request from.
# my $base_url = "http://code.and.org/cgi-bin/imp_retrieval.cgi";
# my $real_base_url = "http://imprints.sourceforge.net/cgi-bin/imp_retrieval.cgi";
# my $real_base_url = "http://imprints.samba.org/imprints/imp_retrieval.cgi";
my $real_base_url = "http://imprints.samba.org/cgi-bin/imp_retrieval.cgi";
my $base_url = undef;

# Paths to external programs we use.
my $path_self = "$FindBin::RealBin/" . basename($0);
my $path_gzip = "gzip";
my $path_tar = "tar";

## commented out as the rpc_client_wrapper.pl script has been
## included in this file as a subroutine --jerry
# my $path_rpc_client_wrapper = "$FindBin::RealBin/../scripts/rpc_client_wrapper.pl";
# my $path_rpc_query_wrapper = "$FindBin::RealBin/../scripts/rpc_query_wrapper.pl";

my $path_rpcclient = "rpcclient";
my $path_smbclient = "smbclient";

# Extra options...
my $option_help = 0; # Do we show help.
my $option_version = 0; # Do we show the version.
my $option_cleanup = 1; # Do we cleanup the temp dir.
my $option_pubkey_install = -1; # -1 = default, 1 = yes, 0 = no
my $option_tmpdir = undef; # Change $ENV{'TMPDIR'}, tmpname() doesn't use it.
my $option_query = 0; # Just do a query for valid printer names.
my $option_rpcquery = 0; # Just do a query for samba stuff.
my $option_verbose = 0; # Show verbose messages during progress.
my $option_authfile = undef; # File for auth input
my $option_language = undef; # Language we want to printer drivers in.
my $option_cache_dir = undef; # Place to cache packages
my $option_pkg_name = undef; # local cached package
my $option_servers_file = undef; # File with a list of servers/languages.

my $DEBUG = 0;

# Parameters sent to the request server.
my @params = ();
my @download_params = ("action=get-printer-info");
my @query_params = ("action=list-printers");

my $tmp_dir = "";

# Error code variables...
my $error_code_default = 1;
my $error_code_request = 2;
my $error_code_query_6 = 3;

# #### End of file scoped variables.
########################################################################

########################################################################
# CD to a known safe directory.
# Params: none
# Returns: directory name.
sub cd_temp ()
{
my $tmp = undef;

# Cd to a known tmp dir...
do {
# Perl doesn't have mktemp() or tempnam().
$tmp = tmpnam();
} until (mkdir($tmp, 0700));

if (!chdir($tmp)) {
fatal_error ("Error: Cannot chdir($tmp): $!", 0);
}

$base_dir = "$tmp/install";
return ($tmp)
}

########################################################################
# Params:
# $base_url = The url from which the request should be made.
# $params = An array of parameters to put on the end of the url.
# $ua = A UserAgent object from LWP.
sub send_request
{
my ($base_url, $params, $ua) = @_;

my $req = HTTP::Request->new('GET' => $base_url . "?" . (join "&", @{$params}));

my $res = $ua->request($req);
if (!$res->is_success) {
fatal_error ("Error: REQ " . $res->status_line, 1, $error_code_request);
}

return ($res->content);
}

########################################################################
# Params:
# $tbl = A table object from RDB.
# Side Effect: Prints table or names and descriptions.
sub output_query_results
{
my ($tbl) = @_;

for (my $i=0; $i <= $#{$tbl->{data}->{"printer_name"}}; $i++) {
my $name = $tbl->{data}->{"printer_name"}[$i];
print("[printer_name]: $name\n");
}
}

########################################################################
# Params:
# $ua = A UserAgent object from LWP.
# $file_name = A Filename to download to.
# $req = A HTTP::Request object.
# Returns: Return value of $ua->request();
sub request_with_feedback
{
my ($ua, $file_name, $req) = @_;

my $expected_length = undef;
my $bytes_received = 0;

my $res = undef;

if (!open(PKG, "> $file_name")) {
return (undef);
}

my $last_timestamp = 0;

$res = $ua->request($req,
sub
{
my ($chunk, $res) = @_;
$bytes_received += length($chunk);

if (!defined ($expected_length)) {
$expected_length = $res->content_length || 0;
}

if ((time - $last_timestamp) > 2) {
$last_timestamp = time;

if ($expected_length) {
my $stats = sprintf ("%d - %d%%\n", $bytes_received,
100 * $bytes_received / $expected_length);
STDOUT->print("Download Status: " . $stats);
}
else {
my $stats = sprintf ("%d\n", $bytes_received);
STDOUT->print("Download Status: " . $stats);
}
}

PKG->print($chunk);
}
);

if (!close(PKG)) {
return (undef);
}

return ($res);
}

########################################################################
# Params:
# $ua = A UserAgent object from LWP.
# $tbl = A table object from RDB.
# Returns: Name of the new package.
sub download_package
{
my ($ua, $tbl) = @_;
my $res = undef;
my $loc = undef;
my $here_before = 0;

if (!scalar(@{$tbl->{data}->{"location_url"}})) {
fatal_error ("Error: No download locations.", 1);
}

while (scalar(@{$tbl->{data}->{"location_url"}})) {
if ($here_before) {
warn "Warn: PKG " . $loc . ": " . $res->status_line . "\n";
}
$here_before = 1;

my $pkg_name = $tbl->{data}->{"package_name"}[0];

# Take out non good chars.
$pkg_name =~ s/([^-a-zA-Z0-9 :._])/X/g;

if (defined ($option_cache_dir) &&
(-r "$option_cache_dir/$pkg_name") &&
(link("$option_cache_dir/$pkg_name", "$pkg_name") ||
copy("$option_cache_dir/$pkg_name", "$pkg_name")))
{
# It's assumed you have to GPG key
$option_pubkey_install = 0;
return ($pkg_name);
}

$loc = $tbl->{data}->{"location_url"}[0];

my $req = HTTP::Request->new('GET' => $loc);

if ($option_verbose) {
$res = request_with_feedback($ua, $pkg_name, $req);
}
else {
$res = $ua->request($req, $pkg_name);
}

if ($res->is_success) {
if (!$option_pubkey_install) {
return ($pkg_name);
}

$loc =~ s!/([^/]+)$!/!;
$loc .= "public_key";

$req = HTTP::Request->new('GET' => $loc);

$res = $ua->request($req, "./public_keys");

if (($option_pubkey_install != 1) || $res->is_success) {
return ($pkg_name);
}

unlink("$pkg_name");
}

RDB_splice_data($tbl, 0, 1);
}

fatal_error ("Error: PKG " . $loc . ": " . $res->status_line, 1);
}

########################################################################
# Params:
# $file_name = The filename of the package that we want to verify.
# $version = The GPG version ID.
# $sig = The GPG signature for the package.
# $crc = The GPG CRC for the signature.
sub verify_package
{
my ($file_name, $version, $sig, $crc) = @_;
my $installed_pubkey = 0;
my $rc = -1;

if ($option_pubkey_install == 1) {
$rc = impgpg_install_pubkey ("./public_keys");
if ($rc != 0) {
fatal_error ("Error: Installing public key. gpg ended "
. "with an exit code of $rc.", 1);
}
}

$rc = impgpg_print_sigfile ("signature", $version, $sig, $crc);
if ($rc != 0) {
fatal_error ("Error: Unable to write signature file.", 1);
}

$rc = impgpg_verify_signature_using_sigfile ($file_name, "signature");
if ($rc != 0) {
my $verify_rc = $rc;

if (-f "./signature") {
if (!$option_pubkey_install || ! -r "./public_keys") {
fatal_error ("Error: Verifying signature for file '$file_name'. "
. "gpg ended with an exit code of $rc.", 1);
return;
}

warn "Warn: Trying to install a newer public key.\n";
$rc = impgpg_install_pubkey ("./public_keys");
if ($rc == 0) {
$rc = impgpg_verify_signature_using_sigfile($file_name, "signature");
if ($rc == 0) {
goto make_cached_copy;
}
}
else {
$rc = $verify_rc;
}
}

fatal_error ("Error: Verifying signature for file '$file_name'. "
. "gpg ended with an exit code of $rc.", 1);
}

make_cached_copy:
if (defined ($option_cache_dir) &&
(! -r "$option_cache_dir/$file_name"))
{
if (!link("$file_name", "$option_cache_dir/$file_name")) {
copy("$file_name", "$option_cache_dir/$file_name");
}
}

}

########################################################################
# Params:
# $file_name = The filename of the package that we want to explode.
sub explode_package
{
my ($file_name) = @_;

if (system("$path_gzip -dc $file_name | $path_tar -xf -")) {
fatal_error ("Error: Couldn't explode package.\n", 1);
}
}

########################################################################
# Finds a case insensitive match to a filename.
# Params:
# $file_name = The filename that we want to find.
# $dir = The path that we find from.
sub get_real_filename
{
my ($file_name, $dir) = @_;
my @files = ();

if (!$file_name || !opendir(DIR, $dir)) {
return (undef);
}

@files = readdir(DIR);

closedir(DIR);

@files = grep (/^$file_name$/i, @files);

if (scalar(@files)) {
return ("$dir/$files[0]");
}

return (undef);
}

######################################################################
# read_authfile
#
## Need to return an array of values
sub read_authfile
{
my ($rpc_authfile, $printer_model_name) = @_;
my @lines = ();
my $rpc_printer_name = "";
my $rpc_share_samba_name = "";
my $rpc_port_name = "";
my $servername = "";
my @return_params = undef;

## read in the authorization file data
if (! open (IN, "< $rpc_authfile")) {
fatal_error("Error: Couldn't open Authorization file.\n");
}
@lines = <IN>;
if (!close (IN)) {
fatal_error("Error: Couldn't close Authorization file.\n");
}

chomp (@lines);

## we only need to handle the printer name, share name, port name,
## and server name. The username/password lines will be read directly
## by smbclient and rpcclient
for (@lines) {
if (/^\s*folder\s+share\s+name\s*=(.+)$/) {
$rpc_printer_name = $1;
}
if (/^\s*samba\s+share\s+name\s*=(.+)$/) {
$rpc_share_samba_name = $1;
}
if (/^\s*printer\s+port\s+name\s*=(.+)$/) {
$rpc_port_name = $1;
}
if (/^\s*server\s*=(.+)$/) {
$servername = $1;
}
}

if ($rpc_printer_name eq "<auto>") {
$rpc_printer_name = $printer_model_name;
}

@return_params = ($rpc_printer_name, $rpc_share_samba_name, $rpc_port_name, $servername);
}

######################################################################
# validate_credentials
#
## return a boolean depending on whether or not we could
## logon to the server
sub validate_credentials
{
my ($server, $authfile) = @_;
my $cmd = undef;
my @cmd_output = undef;
my $auth_failed = 0;
my $bad_hostname = 0;
my $session_request_failed = 0;
my $valid_credentials = 0;

$cmd = "$path_smbclient -L $server -A $authfile";
if ($DEBUG) { print STDERR "$cmd\n"; }
if (!open ( SMBCLIENT, "$cmd|")) {
warn "[rpc]: Unable to open smbclient session!\n";
return 0;
}
@cmd_output = <SMBCLIENT>;
close (SMBCLIENT);

for (@cmd_output) {
if ($DEBUG) { print STDERR "$_"; }

if ($_ =~ /session request.*failed/) {
print "[rpc]: $_";
$session_request_failed = 1;
}

if ($_ =~ /ERRbadpw/) {
$auth_failed = 1;
print "[rpc]: Bad username/password for host $server!.\n";
last;
}

if ($_ =~ /Connection to.*failed/) {
$bad_hostname = 1;
last;
}

if ($_ =~ /IPC\$.*IPC Service/) {
$valid_credentials = 1;
last;
}
}

## reset any failed session requests if we finally got it right
if ($valid_credentials) {
$session_request_failed = 0;
}

if ($session_request_failed) {
print "\n";
print "[rpc]: *****************************************************************\n";
print "[rpc]: A failed session request is usually indicative of\n";
print "[rpc]: some type of netbios name resolution problem. This can\n";
print "[rpc]: also be caused by hosts allow/deny lines in the Samba\n";
print "[rpc]: server's smb.conf(5) file.\n";
print "[rpc]: *****************************************************************\n\n";
}

## if it was a bad hostname, let's try again, but this time supplying
## the IP address as well if we can get it via a gethostbyname() call
if ($bad_hostname) {
my $name = undef;
my $aliases = undef;
my $addrtype = undef;
my $length = undef;
my @addrs = undef;
my ($a, $b, $c, $d);

print "Attempting to resolve $server via gethosybyname()...";
($name, $aliases, $addrtype, $length, @addrs) = gethostbyname($server);
if (defined($name)) {
for (@addrs) {
$bad_hostname = 0;
($a, $b, $c, $d) = unpack('C4', $_);
print "$a.$b.$c.$d...";
$cmd = "$path_smbclient -L $server -A $authfile -I $a.$b.$c.$d";
if ($DEBUG) { print STDERR "$cmd\n"; }
if (!open ( SMBCLIENT, "$cmd|")) {
warn "[rpc]: Unable to open smbclient session!\n";
return "";
}
@cmd_output = <SMBCLIENT>;
close (SMBCLIENT);

for (@cmd_output) {
if ($DEBUG) { print STDERR "$_"; }
if ($_ =~ /ERRbadpw/) {
$auth_failed = 1;
print "[rpc]: Bad username/password for host $server!.\n";
last;
}

if ($_ =~ /Connection to.*failed/) {
$bad_hostname = 1;
last;
}
}

}
}
print "\n";

if ($bad_hostname) {
print "[rpc]: Invalid Print Server name - $server!\n";
}

}

if ($auth_failed || $bad_hostname || $session_request_failed) {
return 0;
}

return 1;
}

######################################################################
# setup_credentials
#
sub setup_credentials
{
my ($tmpfile) = @_;
my $servername = undef;
my $username = undef;
my $password = undef;

if (!open(TMP, "> $tmpfile")) {
STDERR->print ("Unable to open $tmpfile for writing!\n");
return "";
}
##
## get input from user and create the authfile
##
print "Server: ";
$servername = <STDIN>;
chomp ($servername);

print "Username: ";
$username = <STDIN>;
chomp ($username);

print "Password: ";
$password = <STDIN>;
chomp ($password);

## save crendentials and close authfile since
## we will need to pass it to the validate_credentials() function
TMP->print("server=$servername\n");
TMP->print("username=$username\n");
TMP->print("password=$password\n");

close (TMP);

return $servername;
}

######################################################################
# build_authfile
#
## Need to return a filename
sub build_authfile
{
my $tmp_file_name = undef;
my $rpc_printer_name = undef;
my $rpc_share_samba_name = undef;
my $rpc_port_name = undef;
my $servername = undef;
my $username = undef;
my $password = undef;
my $cmd = undef;
my @rpc_output = ();
my ($tmp_str, $string) = undef;
my @port_list = ();
my $port_ok = undef;

## generate a temp file name which can be used as the authfile
## and write out the data
do {
$tmp_file_name = tmpnam();
} while (!sysopen(TMP, $tmp_file_name, O_RDWR|O_CREAT|O_EXCL, 0600));

## get the username, password and server tuple from user
$servername = setup_credentials($tmp_file_name);
if ("$servername" eq "") {
return "";
}

## since we have the servername, username and password,
print "Testing logon credentials...\n";
if (!validate_credentials($servername, $tmp_file_name)) {
## never leave a password lying around (even a bad one)
unlink ($tmp_file_name);
return "";
}

## get the remaining data since the servername/username/password
## tuple has been validated.

print "Printer name (press <ENTER> to default to the printer model name): ";
$rpc_printer_name = <STDIN>;
chomp($rpc_printer_name);
$rpc_printer_name =~ s/\s+//g;
if ( length ($rpc_printer_name) == 0 ) {
$rpc_printer_name = "<auto>";
}

## We can query the remote server also to get the valid port
## names and printer share names
print "Retrieving remote server information...\n";

@rpc_output = rpc_query_wrapper($tmp_file_name, $servername);
print "\tValid Printer Share Names:\n";
for (@rpc_output) {
if ($_ =~ /\[samba_share\]/) {
($tmp_str, $string) = split(/:/, $_);
$string =~ s/^\s+//;
print "\t\t$string\n";
}
}
print "\n";

print "\tValid Port Names:\n";
for (@rpc_output) {
if ($_ =~ /\[printer_port\]/) {
($tmp_str, $string) = split(/:/, $_);
$string =~ s/^\s+//;
chomp ($string);
print "\t\t$string\n";
push (@port_list, $string);
}
}
print "\n";

print "Samba share name: ";
$rpc_share_samba_name = <STDIN>;
chomp($rpc_share_samba_name);

## loop to verify the correctness of the portname
## against the list returned by the server
do {
$port_ok = 0;
print "Printer port: ";
$rpc_port_name = <STDIN>;
chomp($rpc_port_name);

for (@port_list) {
if ("$_" eq "$rpc_port_name") {
$port_ok = 1;
last;
}
}

if (!$port_ok) {
print "Invalid port name!\n";
}
} while (!$port_ok);

if (!open(TMP, ">> $tmp_file_name")) {
print "Unable to reopen the authentication file\n";
return "failed";
}

TMP->print("folder share name=$rpc_printer_name\n");
TMP->print("samba share name=$rpc_share_samba_name\n");
TMP->print("printer port name=$rpc_port_name\n");

close(TMP);

## return the filename
return $tmp_file_name;

}

######################################################################
# rpc_query_wrapper
#
sub rpc_query_wrapper
{

my ($rpc_authfile, $server) = @_;
my $cmd = undef;
my @info = ();

# get the shared printers
$cmd = "$path_smbclient -L $server -A $rpc_authfile";
if (!open (RPC_IN, "$cmd |")) {
fatal_error("Error: Couldn't run $cmd (get enum ports).\n");
}

my $state = 0;
while (<RPC_IN>) {
if (!$state && /^\s*Sharename\s+Type\s+Comment\s*$/) {
$state = 1;
}

last if ($state && /^\s*Server\s+Comment\s*$/);

if ($state && /^\s*(\S+)\s+Printer\s+/) {
push( @info, "[samba_share]: $1");
}
}
close (RPC_IN);

## get the ports
$cmd = "$path_rpcclient $server -d 1 -A $rpc_authfile -c \"enumports 1\"";
if (!open (RPC_IN, "$cmd |")) {
fatal_error("Error: Couldn't run $cmd (get enum ports).\n");
}

while (<RPC_IN>) {
if (/^\s*Port Name:\s*\[([^\]]+)\]\s*$/) {
push (@info, "[printer_port]: $1");
}
}
close (RPC_IN);

@info;
}

######################################################################
# rpc_client_wrapper
#
sub rpc_client_wrapper
{
my @args = @_;

my $cmd_file_name = undef; # We _will_ have to create this

my $cmd = undef; # Throw into
my $cmd_string = undef;
my $cmd_rpc = undef;
my $rpc_output = undef;
my $drv_file = undef;
my $authfile = undef;
my $ret = 1;

## save the current working directory
my $save_cwd = &cwd;

# Stuff that is always passed in as args...
my $printer_model_name = undef;
my $driver_file_name = undef;
my $data_file_name = undef;
my $config_file_name = undef;
my $help_file_name = undef;
my $language_monitor = undef; # unused

my $rpc_printer_name = undef;
my $rpc_share_samba_name = undef;
my $rpc_port_name = undef;
my $servername = undef;
my ($error, $error_string) = undef;

# Values got from rpcclient/smbclient
my $printer_upload_dir = undef; # Dir for first arg to smbclient
my $printer_upload_last = undef; # Dir for in last arg to smbclient

my %arch_map = ("W32X86" => "Windows NT x86",
"WIN40" => "Windows 4.0",
"W32MIPS" => "Windows NT R4000",
"W32ALPHA" => "Windows NT Alpha_AXP",
"W32PPC" => "Windows NT PowerPC");
my $arch = undef; # Right side of above mapping...

## first thing is to grab the authfile name
$authfile = shift (@args);

## make sure this is a valid architecture for printer drivers
if (exists($arch_map{$args[0]})) {
$arch = $arch_map{$args[0]};
shift(@args);
}
else {
fatal_error("Error: Not a supported arch for rpcclient.\n");
}

# grab the remaining fields for a DRIVER_INFO_3 struct
$printer_model_name = shift (@args);
$driver_file_name = shift(@args);
$data_file_name = shift(@args);
$config_file_name = shift(@args);
$help_file_name = shift(@args);
$language_monitor = shift(@args); # unused

## previous generate authfile code was here
( $rpc_printer_name,
$rpc_share_samba_name,
$rpc_port_name,
$servername) = read_authfile($authfile, $printer_model_name);

if (!chdir (dirname($args[0]))) {
fatal_error("ERROR! Couldn't chdir()\n");
}

for (@args) {
$_ = basename($_);
}

print "[rpc]: Installing $arch drivers for $printer_model_name...\n";

##
## Step #1 : get the upload directory for the driver files
##
## see the rpcclient(1) man page for more information
## on this MS-RPC
##
## e.g. getdriverdir "Windows NT x86"

## run the command
$cmd_string = "getdriverdir \\\"$arch\\\"";
$cmd = "$path_rpcclient $servername -d 1 -A $authfile -c \"$cmd_string\"";
if ($DEBUG) { print STDERR "$cmd\n"; }
if (!open (RPC_IN, "$cmd|")) {
fatal_error("ERROR! Couldn't run $cmd (get driver dir).\n");
}

while ($rpc_output = <RPC_IN>) {
if ($DEBUG) { print STDERR "$rpc_output"; }
if ($rpc_output =~ /^\s*Directory Name/) {
$printer_upload_dir = $rpc_output;
last;
}
}

$_ = $printer_upload_dir;

if (!defined ($_) || !s/\s*Directory Name:\[([^\]]+)]\s*/$1/) {
fatal_error("ERROR! Unable to locate printer upload dir.\n");
}

s/\\([^\\]+)$//;
$printer_upload_last = $1;
$printer_upload_dir = $_;
$printer_upload_dir =~ s/\\/\//g;

print "[rpc]: Printer Driver Upload Directory = $_\\$printer_upload_last\n";

##
## Step #2 : upload the driver files to $printer_upload_dir
##
## e.g. prompt; cd "W32X86"; put hp4000_6.ppd; put pscrptui.dll;
## put pscript.hlp; put pscript.dll

## run the command
$cmd_string = "prompt; cd $printer_upload_last";
foreach $drv_file (@args) {
$cmd_string .= "; put $drv_file";
}
$cmd = "$path_smbclient $printer_upload_dir -A $authfile -d 1 -c \"$cmd_string\"";
if ($DEBUG) { print STDERR "$cmd\n"; }
if (!open (RPC_IN, "$cmd|")) {
fatal_error("Error: Couldn't run $cmd (upload driver files).\n");
}

$error = 0;
$error_string = "";
while ($rpc_output = <RPC_IN>) {
if ($DEBUG) { print STDERR "$rpc_output"; }
if ($rpc_output =~ /Connection to.* failed/ ) {
$error = 1;
$error_string = "ERROR! $rpc_output";
last;
}

if ($rpc_output =~ /tree connect failed/) {
$error = 1;
$error_string = "ERROR! smbclient failed to connect to [$printer_upload_dir]";
$error_string .= " Check access settings on share.\n";
last;
}

if ($rpc_output =~ /ERRnosuchshare/ ) {
$error = 1;
$error_string = "ERROR! No access to [$printer_upload_dir]";
last;
}

if ($rpc_output =~ /ERRnoaccess/ ) {
$error = 1;
$error_string = "ERROR! No access to upload files!";
last;
}

if ($rpc_output =~ /^putting file/) {
print "[rpc]: $rpc_output";
}
}
close (RPC_IN);

if ($error) {
print "[rpc]: $error_string\n";
chdir ($save_cwd);
return 0;
}

##
## Step #3 : need an AddPrinterDriver() RPC
##
## see the rpcclient(1) man page for more information on the
## format of this MS-RPC
##
## e.g. adddriver "Windows NT x86" \
## "HP LaserJet 4000 Series PS:PSCRIPT.DLL:HP4000_6.PPD:PSCRPTUI.DLL:\
## PSCRIPT.HLP:NULL:RAW:hp4000_6.ppd,pscrptui.dll,pscript.hlp,\
## pscript.dll"

## run the client program
$cmd_string = "adddriver \\\"$arch\\\" " .
"\\\"$printer_model_name:$driver_file_name:$data_file_name:" .
"$config_file_name:$help_file_name:NULL:RAW:" .
(join (',', @args)) . "\\\"";
$cmd = "$path_rpcclient $servername -d 1 -A $authfile -c \"$cmd_string\"";
if ($DEBUG) { print STDERR "$cmd\n"; }
if (!open (RPC_IN, "$cmd|")) {
fatal_error("Error: Couldn't run $cmd (add printer driver).\n");
}

## parse the output
$error = 0;
$error_string = "";
while ($rpc_output = <RPC_IN>) {

if ($DEBUG) { print STDERR "$rpc_output"; }

## catch errors heres

## successful output
if ($rpc_output =~ /successfully installed/) {
print "[rpc]: $rpc_output";
last;
}
}

if ($error) {
print "[rpc]: $error_string\n";
chdir ($save_cwd);
return 0;
}

##
## Step #4 : invoke an AddPrinter() RPC
##
## e.g. addprinter "HP LaserJet 4000 Series PS" "" \
## "HP LaserJet 4000 Series PS" "Samba Printer Port"
##
## Possible errors include
## - invalid port name
## - bad share name (and unable to create new on on Samba server)

## run the command
$cmd_string = "addprinter " .
"\\\"$rpc_printer_name\\\"" . " " .
"\\\"$rpc_share_samba_name\\\"" . " " .
"\\\"$printer_model_name\\\"" . " " .
"\\\"$rpc_port_name\\\"";
$cmd = "$path_rpcclient $servername -d 1 -A $authfile -c \"$cmd_string\"";
if ($DEBUG) { print STDERR "$cmd\n"; }
if (!open (RPC_IN, "$cmd|")) {
fatal_error("Error: Couldn't run $cmd (add printer).\n");
}

## grab any output to print a message
$error = 0;
$error_string = "";
while ($rpc_output = <RPC_IN>) {

## enable the following line for debugging
if ($DEBUG) { print STDERR "$rpc_output"; }
if ($rpc_output =~ /Invalid port/) {
$error = 1;
$error_string = "ERROR! Invalid port ($rpc_port_name) specified in addprinter command";
last;
}
if ($rpc_output =~ /NT_STATUS/) {
chomp ($rpc_output);
$error = 1;
$error_string = "ERROR! Windows NT error code : [$rpc_output]";
}
if ($rpc_output =~ /successfully installed/) {
print "[rpc]: $rpc_output";
print "[rpc]: Installed arch: $arch\n";
last;
}
}
close (RPC_IN);

if ($error) {
print "[rpc]: $error_string\n";
chdir ($save_cwd);
return 0;
}

## return to the previous working directory
chdir ($save_cwd);

return 1;
}

########################################################################
# locate_client_programs
#
sub locate_client_programs
{
## let's verify that smbclient and rpcclient are actually
## in the search path and can be found
my @path = ();
my @dirs = ();
my $found = 0;

## look for rpcclient
push (@path, dirname($path_rpcclient));
@dirs = split(/:/, $ENV{'PATH'});
push (@path, @dirs);
for (@path) {
if (-f "$_/$path_rpcclient") {
$found = 1;
last;
}
}
if (! $found ) {
print "ERROR! Unable to locate rpcclient binary!\n";
print "Please make sure the following is a valid path\n";
print "(or is in your search path):\n";
print "\t$path_rpcclient\n";
return 0;
}

## look for smbclient
$found = 0;
@path = ();
push (@path, dirname($path_smbclient));
push (@path, @dirs);
for (@path) {
if (-f "$_/$path_smbclient") {
$found = 1;
last;
}
}
if (! $found ) {
print "ERROR! Unable to locate smbclient binary!\n";
print "Please make sure the following is a valid path\n";
print "(or is in your search path):\n";
print "\t$path_smbclient\n";
return 0;
}

return 1;
}

########################################################################
# Params:
# $inf = Return value from read_inf() call, on the control file for a package.
sub install_package
{
my ($inf) = @_;
my $tmp_file_name = undef;
my $ret = 1;

if (!locate_client_programs()) {
return 0;
}

## now onto more important stuff....
if (!inf_has_key($inf, "W32X86")) {
fatal_error ("ERROR! Package doesn't include a \"Windows NT x86\" driver set.\n", 1);
}

while ((!defined($option_authfile)) || (length($option_authfile)==0)) {
## generate a temp file name which can be used as the authfile
## and write out the data
do {
$tmp_file_name = tmpnam();
} while (!sysopen(TMP, $tmp_file_name, O_RDWR|O_CREAT|O_EXCL, 0600));

$tmp_file_name = build_authfile();
$option_authfile = $tmp_file_name;
}

for my $arch ("W32X86", "WIN40", "W32mips", "W32alpha", "W32ppc") {
if (!inf_has_key($inf, $arch)) {
next;
}

my $inf_arch = inf_get_key($inf, $arch);
my $arch_file_name = inf_get_key($inf_arch, "inf_fname");

my $inf_hack_arch = inf_get_key($inf, "W32X86");

if ($arch_file_name) {
my $tmp_inf = read_inf("$arch/$arch_file_name");

if (!defined($tmp_inf)) {
warn "Warn: Bad arch INF file: $arch.\n";
next;
}

my $model_name = inf_get_key($inf_arch, "model");

if ($arch eq "WIN40") {
# '9x uses NT arch model name.
$model_name = inf_get_key($inf_hack_arch, "model");
}
my %info = parse_inf_nt($tmp_inf,
inf_get_key($inf_arch, "manufacturer"),
inf_get_key($inf_arch, "model"),
$arch);

if (!%info) {
warn "Warn: Invalid arch INF file: $arch.\n";
next;
}

my @rpc_args = ();
my $arg_string = undef;
my $printer_model_name = inf_get_key($inf_arch, "model");

push (@rpc_args, $option_authfile);

push (@rpc_args, $arch);
push (@rpc_args, $printer_model_name);

print "[rpc]: Printer Driver Information : \n";
print "[rpc]: Printer Model = $rpc_args[$#rpc_args]\n";
print "[rpc]: Environment = $arch\n";

push (@rpc_args, $info{"DriverFile"});
push (@rpc_args, $info{"DataFile"});
push (@rpc_args, $info{"ConfigFile"});
push (@rpc_args, $info{"HelpFile"});
push (@rpc_args, $info{"LanguageMonitor"});

print "[rpc]: Driver Filename = " . $info{'DriverFile'} . "\n";
print "[rpc]: Data Filename = " . $info{'DataFile'} . "\n";
print "[rpc]: Config Filename = " . $info{'ConfigFile'} . "\n";
print "[rpc]: Help Filename = " . $info{'HelpFile'} . "\n";

# Install the files...
for my $filehash (@{$info{CopyFiles}}) {
# $src is not to be used.
my $dst = $filehash->{DstFilename};
my $src = get_real_filename($dst, $arch);

if (!defined($src)) {
warn "Warn: File not found: '$dst' in $arch.\n";
next;
}

$dst = lc($dst); # Because they are usually upper case.
# and $src contains the arch again.

my $loc = "$base_dir/$arch/$dst";

if (! -d dirname($loc) && !mkpath(dirname($loc), 0, 0755)) {
warn "Warn: mkpath: Couldn't create directories\n";
next;
}

if (!copy($src, $loc)) {
warn "Warn: copy: $!\n";
next;
}

push(@rpc_args, $loc);
}

if (!rpc_client_wrapper(@rpc_args)) {
## return an error
return 0;
}
}
}

if (defined($tmp_file_name)) {
unlink ($tmp_file_name);
}

return 1;
}

########################################################################
# Clean up the temporary directory and its files.
#-----------------------------------------------------------------
sub cleanup
{

if ($option_cleanup == 1) {
if (! chdir("/")) {
warn "Warn: Couldn't chdir to / $!\n";
return;
}

status_msg ("Cleaning up temporary files...");
rmtree($tmp_dir);

## very important to remove this file if it exists!!
#if (defined($option_authfile)) {
# unlink ($option_authfile);
#}

}
}

########################################################################
# handle_package
#
##
sub handle_package {

my ($pkg_name) = @_;
my $res = undef;
my $control_inf = undef;

status_msg ("Exploding package...");

explode_package($pkg_name);

$control_inf = read_inf("./control");

if (!defined($control_inf)) {
fatal_error ("Error: Bad control INF file.", 1);
}

status_msg ("Installing package...");

$res = install_package($control_inf);

return ($res);
}
########################################################################
# In case of an unrecoverable error, print a message to STDERR,
# optionally perform cleanup, and exit.
#-----------------------------------------------------------------
sub fatal_error
{
my ($msg, $do_cleanup, $error_code) = @_;

if (!defined ($error_code) || !$error_code) {
$error_code = $error_code_default;
}

# FIXME: output twice (GUI would like to see the real error _first_ atm.
STDERR->print ("$msg\n");

if ($do_cleanup != 0) {
cleanup ();
}

STDERR->print ("\n\n$msg\n");

exit ($error_code);
}

########################################################################
# If verbose mode is on, then print the status message to STDOUT.
#-----------------------------------------------------------------
sub status_msg
{
my ($msg) = @_;

if ($option_verbose == 1) {
print "$msg\n";
}
}

########################################################################
# #### Main #### #
########################################################################
my @saved_argv = @ARGV;

local($|) = 1;

# Don't let anyone mess with the files.
$tmp_dir = cd_temp();

# Getopt stuff...

# Getopt::Long::Configure ("bundling");

my $res = GetOptions('help|h' => \$option_help,
'base-url|b=s' => \$base_url,
'host=s' =>
sub
{
if ($_[1] ne '')
{
$base_url = $real_base_url;
$base_url =~
s!^http://([^/]+)/(.+)$!http://$_[1]/$2!;
}
else
{
$base_url = '';
}
},
'servers=s' => \$option_servers_file,
'query!' => \$option_query,
'rpcquery!' => \$option_rpcquery,
'cleanup!' => \$option_cleanup,
'verbose' => \$option_verbose,
'local-pkg=s' => \$option_pkg_name,
'authfile=s' => \$option_authfile,
'cache-dir=s' => \$option_cache_dir,
'language=s' => \$option_language,
'pubkey-install!' => \$option_pubkey_install,
'version|v' => \$option_version,
'debug|d' => \$DEBUG);

# Allow the query option to take no parameter,
# this will match all printers.
if (($option_query || $option_rpcquery) && (scalar (@ARGV) != 1)) {
$ARGV[0] = "";
}

if (!$option_help && (scalar (@ARGV) != 1)) {
$res = 0;
}

if (!$res || $option_help) {
STDERR->print(" Format: $0 [options] <name>\n");
STDERR->print(" --help -h - Print this message.\n");
STDERR->print(" --debug -d - log debug information to stderr.\n");
STDERR->print(" --version -v - Print the version.\n");
STDERR->print(" --base-url - Change the url to query requests from.\n");
STDERR->print(" --cache-dir=<dir> - Cache driver file packages in <dir>\n");
STDERR->print(" --local-pkg=<file> - Install a locally archived driver pkg\n");
STDERR->print(" --host - Change the host in the request url.\n");
STDERR->print(" --query - Do a query for fully qualified printer names.\n");
STDERR->print(" --rpcquery - Do an rpc query for samba details.\n");
STDERR->print(" --cleanup - Should we cleanup the tmp directory.\n");
STDERR->print(" --authfile - File which contains authorization information.\n");
STDERR->print(" --pubkey-install - Always install new public keys for the package.\n");
STDERR->print(" --verbose - Print progress messages during each program step.\n");
STDERR->print("\n");

cleanup ();
exit (!$res);
}

if ($option_version) {
print "$0: Version 1.0.0\n";
cleanup ();
exit (0);
}

if (!defined ($ENV{'TMPDIR'})) {
$ENV{'TMPDIR'} = "/tmp/";
}

if ($option_pkg_name) {
$res = handle_package("$option_cache_dir/$option_pkg_name");
cleanup();
exit ($res);
}

# #### MAIN server list code ####
if (!defined ($base_url) && defined($option_servers_file)) {

# So it works recursivly.
if (!open (SERV_IN, "< $option_servers_file")) {
fatal_error(" Couldn't open server list: $!\n", 1);
}

my @lines = <SERV_IN>;
chomp(@lines);

my $tbl = RDB_parse_array(@lines);

close(SERV_IN);

my $first = 1;
while (scalar(@{$tbl->{data}->{"host"}})) {
if (!$first) {
status_msg ("Auto restarting with the next server...");
}

$first = 0;

my @xtra_args = ();

if ($tbl->{data}->{"language"}[0] ne '') {
push(@xtra_args, "--language");
push(@xtra_args, $tbl->{data}->{"language"}[0]);
}

# Might still be undef.
elsif (defined($option_language)) {
push(@xtra_args, "--language");
if (!defined($option_language)) {
$option_language = '';
}
push(@xtra_args, $option_language);
}

if ($tbl->{data}->{"url"}[0] ne '') {
push(@xtra_args, "--base-url");
push(@xtra_args, $tbl->{data}->{"url"}[0]);
}
else {
push(@xtra_args, "--host");
push(@xtra_args, $tbl->{data}->{"host"}[0]);
}

$res = system($path_self, @saved_argv, @xtra_args);
$res /= 256;

if (($res != $error_code_query_6) && ($res != $error_code_request)) {
last;
}

RDB_splice_data($tbl, 0, 1);
}

cleanup();
exit ($res);
}

if (!defined ($base_url) || ($base_url eq '')) {
$base_url = $real_base_url;
}

# #### MAIN rpcquery code ####
if ($option_rpcquery) {
my $tmp_file_name = undef;
my $server = undef;
my @args = ();
my @rpc_output = ();

if (!locate_client_programs()) {
exit 0;
}

if (!defined ($option_authfile)) {
## generate a temp file name which can be used as the authfile
## and write out the data
do {
$tmp_file_name = tmpnam();
} while (!sysopen(TMP, $tmp_file_name, O_RDWR|O_CREAT|O_EXCL, 0600));

$server = setup_credentials($tmp_file_name);
$option_authfile = $tmp_file_name;
}
else {
@args = read_authfile($option_authfile);
$server = $args[3];
}

if (validate_credentials($server, $option_authfile)) {
@rpc_output = rpc_query_wrapper($option_authfile, $server);
for (@rpc_output) {
print "$_\n";
}

}
else {
print STDERR "Invalid credentials!\n";
}

if (defined($tmp_file_name)) {
unlink($tmp_file_name);
}
cleanup();
exit 0;
}

# #### MAIN query and install code ####

# http-ify the parameter.
$ARGV[0] =~ s/([^a-zA-Z0-9])/"%" . sprintf("%02x", ord($1))/eg;

if ($option_query) {
@params = @query_params;
if ($#ARGV >= 0) {
push (@params, "printer-name=" . $ARGV[0]);
}
}
else {
@params = @download_params;
push (@params, "printer-name=" . $ARGV[0]);
}

if (defined ($option_language) && ($option_language ne '')) {
# http-ify the parameter.
$option_language =~ s/([^a-zA-Z0-9])/"%" . sprintf("%x", ord($1))/eg;
push (@params, "lang=" . $option_language);
}

# Do downloads...

my $ua = LWP::UserAgent->new();

$ua->agent("Imprints-Client/1.0 " . $ua->agent);
$ua->env_proxy();

status_msg ("Sending request to server $base_url...");

my $request_data = send_request($base_url, \@params, $ua);

status_msg ("Parsing RDB table...");

my $tbl = RDB_parse_string($request_data);

if (!defined ($tbl)) {
fatal_error ("Error: Failed to parse information from retrieval server.", 1);
}

# Check for error_code in returned table.
if (exists ($tbl->{data}->{"error_code"})) {
my $error_code = $tbl->{data}->{"error_code"}[0];
my $error_desc = $tbl->{data}->{"error_desc"}[0];
my $err = $error_code_default;

# Not found error code...
if ($error_code == 6) {
$err = $error_code_query_6;
}

fatal_error ("Error: Query failed with return code=$error_code. $error_desc.", 1, $err);
}

if ($option_query) {
output_query_results($tbl);
cleanup ();
exit (0);
}

status_msg ("Downloading package...");
my $pkg_name = download_package($ua, $tbl);

# Deal with the package...
status_msg ("Verifying package using gpg...");

verify_package($pkg_name,
$tbl->{data}->{"gpg_version"}[0],
$tbl->{data}->{"gpg_sig"}[0],
$tbl->{data}->{"gpg_crc"}[0]);

$res = handle_package ($pkg_name);

# Cleanup temporary storage...
cleanup ();

if ($res) {
print("Installation completed successfully.\n");
}
else {
print("Installation experienced problems.\n");
}

exit ($res);