~vcs-imports/personalbackup/trunk

#!/usr/bin/perl -w

# $Id: personalbackupc 177 2007-02-01 23:25:12Z linuxtuxie $

#############################################################################
# PersonalBackup -  A company-wide solution for backing up all your         #
#                   Windows machines and Samba shares                       #
#                                                                           #
# Copyright (C) 2004 Kim Kuylen / Melexis                                   #
#                                                                           #
# This program is free software; you can redistribute it and/or             #
# modify it under the terms of the GNU General Public License               #
# as published by the Free Software Foundation.                             #
#############################################################################

use lib "__libinstalldir__";
use strict;
use DBI;
use PBUtils;
use PBConfig;
use PBDatabase;
use PBMessage;

use HTML::Template;
use POSIX qw(strftime);
use Filesys::SmbClient;
use File::Find;
use File::Path;
use Net::Ping;
use IO::Socket qw(inet_aton);
use MLDBM qw(DB_File Storable);
use Fcntl;

##########################################
# configuration
##########################################
my $conf            = new PBConfig("__confdir__/personalbackup.conf");
my $installdir      = $conf->get("installdir");
my $templatedir     = $conf->get("templatedir");
my $maxclients      = $conf->get("maxclients");
my $clienttimeout   = $conf->get("clienttimeout");
my $tempdir         = $conf->get("tempdir");
my $pooldir         = $conf->get("pooldir");
my $webserver       = $conf->get("webserver");
my $workgroup       = $conf->get("workgroup");
my $messagedelay    = $conf->get("messagedelay");
my $maxretry        = $conf->get("maxretry");
my $excluderef      = $conf->get("excludefiles");
my $excludecvs      = $conf->get("excludecvs");
my $smbclient       = $conf->get("smbclient");
my $vpnrange        = $conf->get("vpnrange");
my $mkdir           = $conf->get("mkdir");
my $cp              = $conf->get("cp");
my $backupthreshold = $conf->get("backupthreshold");
my $pinginterval    = $conf->get("pinginterval");
my $DEBUG           = $conf->get("DEBUG");
my @excludefiles    = @$excluderef;
my $language        = "en";

# Getting machine id, name, ip address and ppid from personalbackupd
my $machine_id   = $ARGV[0];
my $machine_name = $ARGV[1];
my $machine_ip   = $ARGV[2];
my $ppid         = $ARGV[3];

my $pid = $$;
my $weeknumber = int( strftime( "%W", localtime ) );
( my $day, my $year, my $dow ) = (localtime)[ 3, 5, 6 ];

my (@shares,           $smb,               $local_logon,
    %remote_file_list, $backup_size,       $skip_size,
    $limit_size,       $backup_file_count, $skip_count,
    $old_backup_id,    $backup_id,         $maxbackupsize,
    $maxvpnsize,       $backup_location,   $current_backup_exists
);

##########################################
### START of main program
##########################################

if (not(   defined($machine_id)
        && defined($machine_name)
        && defined($machine_ip)
        && defined($ppid) )
    )
{
    print
        "It is not the intention to run personalbackupc directly from the command line.\n";
    exit(1);
}

# Catch SIGTERM signal
$SIG{TERM} = \&quit_client;
$SIG{ALRM} = \&alarm_client;

# If alarm overflows, something has gone wrong (like pc shutted down during backup), if this happens we commit suicide :)
alarm($clienttimeout);

# Create database connection
my $dbh = new PBDatabase();

# Reset all shares by setting all skipped shares for the specified machine to scheduled
my $query =
      "UPDATE shares"
    . "   SET backed_up = ?"
    . "     , progress = 0"
    . " WHERE machine_id = ?"
    . "   AND backed_up IN (?, ?, ?)";
$dbh->exec_dml( $query, $STATUS{"scheduled"}, $machine_id, $STATUS{"skipped"},
    $STATUS{"oneskipped"}, $STATUS{"copying"} );

# Detect if the machine is connected through a vpn connection.
my $vpn_enabled = &detectvpn($machine_ip);

# Get the list of shares for the specified machine which are enabled and scheduled for today
$query =
      "SELECT s.id"
    . "     , u.username"
    . "     , m.type"
    . "     , s.share_name"
    . "     , s.username"
    . "     , s.password"
    . "     , s.maxbackupsize"
    . "     , s.vpn"
    . "     , s.maxvpnsize"
    . "     , u.language"
    . "  FROM shares s"
    . "     , machines m"
    . "     , users u"
    . " WHERE s.machine_id = m.id"
    . "   AND m.id = '$machine_id'"
    . "   AND s.backed_up = '"
    . $STATUS{"scheduled"} . "'"
    . "   AND u.id=m.user_id"
    . "   AND (s.schedule & (2^$dow)::integer) > 0"
    . "   AND s.enabled='Y'";

my $result = $dbh->exec_select($query);
foreach my $data (@$result) {
    my ($share_id,   $user,     $type,          $share_name,
        $username,   $password, $maxbackupsize, $vpn,
        $maxvpnsize, $language
    ) = @$data;
    my %share = (
        share_id      => $share_id,
        user          => $user,
        type          => $type,
        share_name    => $share_name,
        username      => $username,
        password      => $password,
        vpn           => $vpn,
        maxvpnsize    => $maxvpnsize,
        maxbackupsize => $maxbackupsize
    );
    push @shares, \%share
        if ( $vpn_enabled eq 'N' ) || ( $vpn_enabled eq 'Y' && $vpn eq "Y" );
}

# Sending notification mail if the user wants it :)
if (@shares) { &sendnotification(); }
else {
    PBUtils->logclient( $machine_name, $pid, "info",
        "Nothing to backup for machine '$machine_name'...maybe all shares are not scheduled or disabled?"
    );
}

foreach my $share (@shares) {
    PBUtils->logclient( $machine_name, $pid, "info",
        "Processing share: '" . $share->{share_name} . "'" );
    PBUtils->logclient( $machine_name, $pid, "info",
        "PC operating system type: " . $share->{type} );
    PBUtils->logclient( $machine_name, $pid, "info",
              "Share '"
            . $share->{share_name}
            . "' scheduled for day of week "
            . $dow );
    my @folders;
    my $query =
          "SELECT f.dirname"
        . "  FROM folders f"
        . " WHERE f.share_id = '"
        . $share->{share_id} . "'";
    my $result = $dbh->exec_select($query);
    foreach my $data (@$result) {
        my ($folder) = @$data;
        push( @folders, $folder );
    }

    # If smbclient is successful
    ( my $smbresult ) = &smbclient(
        $share->{share_id}, $share->{share_name},
        $share->{username}, $share->{password}
    );
    PBUtils->logclient( $machine_name, $pid, "info",
        "Attempt to connect with SmbClient: $smbresult" );
    if ( $smbresult eq "OK" ) {
        my $start_conn = time;
        $maxbackupsize = 0;
        $maxvpnsize    = 0;
        PBUtils->logclient( $machine_name, $pid, "info",
            "SmbClient started at $start_conn" );
        &perform_backup(
            $machine_id,          $share->{share_id},
            $share->{share_name}, $share->{username},
            $share->{password},   \@folders,
            $share->{user},       $share->{maxbackupsize},
            $share->{maxvpnsize}
        );

        # Backup has been performed
        &smbclient_close( $share->{share_id}, $start_conn );
    }
    else {    # If smbclient failed
        &backup_failed( $share->{share_id},
            "Smbclient connection failed. Skipping backup of share '$share->{share_name}'"
        );
    }
    &skipshare( $share->{share_id} );
}

if (@shares) {

# Make sure that we do not get kicked out during the handling of this piece of code
    alarm($clienttimeout);

    # Set the final status of the machine
    my $result = &setmachinestatus();

# Only send a mail now if all shares are backed up successfully and if the users wants to receive it
    if ($result) { &sendresult(); }
}

##########################################
### END of main program
##########################################

##########################################
### START of subroutines
##########################################

sub process_tree {
    my ( $folder, $share_id ) = @_;
    my @folder_todo_list = ();
    if ( my $fd = $smb->opendir("smb://$machine_ip/$folder") ) {
        while ( my $f = $smb->readdir_struct($fd) ) {
            if (   ( $f->[0] == SMBC_DIR )
                && ( $f->[1] ne '.' )
                && ( $f->[1] ne '..' ) )
            {
                push @folder_todo_list, "${folder}$f->[1]/";
            }
            elsif ( $f->[0] == SMBC_FILE )
            {    # If it is not a folder...process it
                my $remote_file = "${folder}$f->[1]";
                my @tab = $smb->stat("smb://$machine_ip/$remote_file");
                my $ref = $remote_file_list{"$remote_file"};
                $ref->{mtime}  = $tab[ $SMBSTAT{"mtime"} ];
                $ref->{size}   = $tab[ $SMBSTAT{"size"} ];
                $ref->{folder} = "$folder";
                $ref->{status} = '';

                my $filetostat;
                if ((   ($current_backup_exists)
                        && ( -f "$backup_location/current.backup/$remote_file"
                        )
                        && ( $filetostat =
                            "$backup_location/current.backup/$remote_file" )
                    )
                    || (   ( defined($old_backup_id) )
                        && ( $old_backup_id ne "" )
                        && ( -f "$backup_location/$old_backup_id/$remote_file"
                        )
                        && ( $filetostat =
                            "$backup_location/$old_backup_id/$remote_file" )
                    )
                    )
                {

                    # did we already backup this file
                    my @stats = stat($filetostat);
                    $ref->{status} = 'b'
                        if (
                        (   $tab[ $SMBSTAT{"mtime"} ]
                            == $stats[ $UNIXSTAT{"mtime"} ]
                        )
                        && ( $tab[ $SMBSTAT{"size"} ]
                            == $stats[ $UNIXSTAT{"size"} ] )
                        );    # is the file same size and time
                    if ($DEBUG) {
                        my ( $datesign, $sizesign );
                        $tab[ $SMBSTAT{"mtime"} ]
                            == $stats[ $UNIXSTAT{"mtime"} ]
                            ? $datesign = "<>"
                            : $datesign = "=";
                        $tab[ $SMBSTAT{"size"} ]
                            == $stats[ $UNIXSTAT{"size"} ]
                            ? $sizesign = "<>"
                            : $sizesign = "=";
                        PBUtils->logclient( $machine_name, $pid, "info",
                            "$backup_location/current.backup/$remote_file : [date] "
                                . $tab[ $SMBSTAT{"mtime"} ]
                                . " $datesign "
                                . $stats[ $UNIXSTAT{"mtime"} ]
                                . " | [size] "
                                . $tab[ $SMBSTAT{"size"} ]
                                . " $sizesign "
                                . $stats[ $UNIXSTAT{"size"} ] );
                    }
                }

                if ($excludecvs) {
                    $ref->{status} = 's' if ( $remote_file =~ /cvs\/root/i );
                    $ref->{status} = 's'
                        if ( $remote_file =~ /cvs\/repository/i );

                    # We automatically skip all files that are under cvs
                    if ( $remote_file =~ /^(.*?)\/cvs\/entries/i ) {
                        my $basedir = $1;
                        my $entries = "";
                        $ref->{status} = 's';
                        if ( my $fd =
                            $smb->open("smb://$machine_ip/$remote_file") )
                        {
                            while ( defined( my $part = $smb->read($fd) ) ) {
                                if ( $part eq "-1" && $! != 0 ) {
                                    PBUtils->logclient( $machine_name, $pid,
                                        "err",
                                        "ERROR DETECTED DURING COPY!!: $!" );
                                }
                                $entries .= $part;
                            }
                            $smb->close($fd);

                            # Replace cr/lf with lf
                            $entries =~ s/\r\n/\n/g;

                            foreach ( split( '\n', $entries ) ) {
                                if (/^\/(.*?)\//) {
                                    my $temp     = $basedir . "/" . $1;
                                    my $temp_ref = $remote_file_list{$temp};
                                    $temp_ref->{status} = 's';
                                    $remote_file_list{$temp} = $temp_ref;
                                    $skip_count++;
                                }
                            }
                        }
                        else {
                            PBUtils->logclient( $machine_name, $pid, "err",
                                "Can't open file smb://$machine_ip/$remote_file for reading: $!"
                            );
                        }
                    }
                }

        # We automatically skip some files defined in /etc/personalbackup.conf
                for (@excludefiles) {
                    my $excludeitem = $_;
                    if ( $remote_file =~ /${excludeitem}/i ) {
                        $ref->{status} = 's';
                        $skip_count++;
                    }
                }

                if ( $remote_file =~ /;/ )
                { # We are not even going to try to backup files which have a ; in their filename!
                    $ref->{status} = 's';
                }

         # Exclude all files if the maximum (vpn) backup size has been reached
                if ( $ref->{status} eq 's' ) {
                    $skip_size += $ref->{size};
                }
                elsif ( $ref->{status} eq 'b' ) {
                    $backup_size += $ref->{size};
                    $backup_file_count++;
                }
                elsif (
                    (      $maxbackupsize != 0
                        && $backup_size >= ( $maxbackupsize * 1024 * 1024 )
                    )
                    || (   $maxvpnsize != 0
                        && $backup_size >= ( $maxvpnsize * 1024 * 1024 )
                        && $vpn_enabled eq 'Y' )
                    )
                {
                    $ref->{status} = 'l';
                    $limit_size += $ref->{size};
                    $skip_count++;
                }
                else {
                    $backup_size += $ref->{size};
                    $backup_file_count++;
                }

                $remote_file_list{"$remote_file"} = $ref;
            }
        }

        # all files are processed... process folders now
        foreach my $folder_todo (@folder_todo_list) {
            &process_tree( "$folder_todo", $share_id );
        }
        $smb->close($fd);
    }
    else {
        PBUtils->logclient( $machine_name, $pid, "err",
            "Error in process_tree routine -> opendir(\"smb://$machine_ip/$folder\"): $!"
        );
    }
}

sub process_modtime {
    my ( $file, $tmpdir ) = @_;

    # Change the modification date of the local file.
    my $ref = $remote_file_list{$file};
    PBUtils->logclient( $machine_name, $pid, "info",
        "Changing modification date of local file '$file' to $ref->{mtime}" )
        if $DEBUG;
    my $rslt = utime( $ref->{mtime}, $ref->{mtime}, "$tmpdir/$file" );
    PBUtils->logclient( $machine_name, $pid, "err",
        "Failed to execute \"utime($ref->{mtime},$ref->{mtime},\"$tmpdir/$file\")\""
    ) unless $rslt != 0;
}

sub sendnotification {
    my $starttime = sprintf( "%02d:%02d",
        ( localtime( time + $messagedelay ) )[2],
        ( localtime( time + $messagedelay ) )[1] );

    # Send a notification mail if the user wants it
    my $query =
          "SELECT u.username"
        . "     , m.email"
        . "     , u.emailadres"
        . "     , m.notification"
        . "  FROM machines m"
        . "     , users u"
        . " WHERE m.machine_name = '$machine_name'"
        . "   AND u.id=m.user_id";
    my ( $user, $email, $emailaddress, $notification ) =
        $dbh->exec_single_select($query);

    PBUtils->logclient( $machine_name, $pid, "info",
        "Start client for user '$user' machine '$machine_name' ip '$machine_ip'"
    );

    if ( $email eq 'Y' && $notification eq 'Y' ) {
        PBMessage->send_notif_mail( $machine_name, $pid, $language,
            $starttime, $emailaddress );
        PBUtils->logclient( $machine_name, $pid, "info",
            "Now waiting for '$messagedelay' seconds before continuing." );
        sleep($messagedelay);
    }
}

sub sendresult {

    my $query =
          "SELECT u.emailadres"
        . "     , u.language"
        . "     , m.info"
        . "     , m.email"
        . "  FROM machines m"
        . "     , users u"
        . " WHERE m.machine_name = '$machine_name'"
        . "   AND u.id=m.user_id";

    my ( $emailaddress, $language, $info, $email ) =
        $dbh->exec_single_select($query);

    if ( $info eq 'Y' && $email eq 'Y' ) {
        PBMessage->send_overview_mail( $machine_name, $pid, $language,
            $emailaddress );
    }

}

sub smbclient {
    my ( $share_id, $share_name, $username, $password ) = @_;
    my ( $fd, $logon );
    my $error = "OK", $local_logon = "";

    # Set status to busy
    $dbh->exec_dml( "UPDATE shares SET backed_up = ? WHERE id = ?",
        $STATUS{"copying"}, $share_id );

    # Try to connect to the remote machine
    if ((   $smb = new Filesys::SmbClient(
                username  => "${username}",
                password  => "$password",
                workgroup => "$workgroup",
                debug     => 1
            )
        )
        )
    {
        if ( ( $fd = $smb->opendir("smb://$machine_ip/$share_name") ) ) {
            $smb->close($fd);
            $logon = "Domain Logon";
        }
        else {
            $error =
                "Error connecting to machine '$machine_ip - $machine_name' with Domain Logon: "
                . $!;
        }
    }
    else {
        $error =
            "Error connecting to machine '$machine_ip - $machine_name': "
            . $!;
    }

# If the previous attempt did not work, try again with username "machine\\user"
    if ( $error ne "OK" ) {
        $error       = "OK";
        $local_logon = "${machine_name}\\";
        if ((   $smb = new Filesys::SmbClient(
                    username  => "${local_logon}${username}",
                    password  => "$password",
                    workgroup => "$workgroup",
                    debug     => 1
                )
            )
            )
        {
            if ( ( $fd = $smb->opendir("smb://$machine_ip/$share_name") ) ) {
                $smb->close($fd);
                $logon = "Non Domain Logon";
            }
            else {
                $error =
                    "Error connecting to machine '$machine_ip - $machine_name' with Non Domain Logon: "
                    . $!;
            }
        }
        else {
            $error =
                "Error connecting to machine '$machine_ip - $machine_name': "
                . $!;
        }
    }

    # Log the error
    if ( $error ne "OK" ) {
        PBUtils->logclient( $machine_name, $pid, "err", $error );
    } else {
       PBUtils->logclient( $machine_name, $pid, "info", $logon );
    }

    return ($error);
}

sub perform_backup {
    my ($machine_id, $share_id,      $share_name,
        $username,   $password,      $subdir_ref,
        $user,       $maxbackupsize, $maxvpnsize
    ) = @_;
    my ($start_backup, $stop_backup,  $backup_time, $status,
        $subdir,       $log_location, $remote_file
    );
    my @folders = @$subdir_ref;

    %remote_file_list  = ();    # Empty the remote file list.
    $backup_size       = 0;
    $skip_size         = 0;
    $limit_size        = 0;
    $backup_file_count = 0;
    $skip_count        = 0;

    PBUtils->logclient( $machine_name, $pid, "info",
        "Performing backup for share $share_name ($share_id)" );

# See if the machine is still connected to the network, if not stop the backup attempt!
    &reset_alarm();

    $backup_location = "${pooldir}/${machine_name}/${share_id}";
    my $query =
          "SELECT backup_id"
        . "  FROM backuplog"
        . " WHERE status='S'"
        . "   AND share_id='$share_id'"
        . "   AND backup_date = (SELECT MAX(backup_date) FROM backuplog WHERE share_id='$share_id' AND status='S')";
    ($old_backup_id) = $dbh->exec_single_select($query);
    if ( -d "$backup_location/current.backup" ) {

# Something went wrong the last time...so we are just going to continue were we left off.
        $current_backup_exists = 1;
        PBUtils->logclient( $machine_name, $pid, "info",
            "Incomplete backup set found...going to continue were we left off."
        );
    }
    elsif (
        !( $old_backup_id ne "" && -d "$backup_location/$old_backup_id" ) )
    {
        $old_backup_id = "";
    }

    unlink("${backup_location}/current.backup.dbm")
        if ( -e "${backup_location}/current.backup.dbm" );

    # Remove lock if it should exist after improper cleanup
    unlink("${backup_location}/__db.current.backup.dbm")
        if ( -e "${backup_location}/__db.current.backup.dbm" );

    tie %remote_file_list, "MLDBM", "${backup_location}/current.backup.dbm",
        O_RDWR | O_CREAT, 0644
        || PBUtils->logclient( $machine_name, $pid, "die",
        "Cannot tie dbm file '${backup_location}/current.backup.dbm': $!" );

    PBUtils->logclient( $machine_name, $pid, "info",
        "Creating remote file list of current share." );
    foreach $subdir (@folders) {
        &process_tree( "${share_name}${subdir}", $share_id );

        ( my $backup_size_conv ) = PBUtils->convert($backup_size);
        ( my $skip_size_conv )   = PBUtils->convert($skip_size);
        PBUtils->logclient( $machine_name, $pid, "info",
            "Backup size for share '$subdir' $backup_size_conv" );
        PBUtils->logclient( $machine_name, $pid, "info",
            "Skip size for share '$subdir' $skip_size_conv" );
        if ( $limit_size > 0 ) {
            my ($limit_size_conv) = PBUtils->convert($limit_size);
            if ( $vpn_enabled eq 'Y' ) {
                PBUtils->logclient( $machine_name, $pid, "info",
                    "Maximum vpn backup size of $maxvpnsize Mb reached. Skipped $limit_size_conv for share '$subdir'"
                );
            }
            else {
                PBUtils->logclient( $machine_name, $pid, "info",
                    "Maximum backup size of $maxbackupsize Mb reached. Skipped $limit_size_conv for share '$subdir'"
                );
            }
        }
    }

    # Figure out if we already tried backed up today
    $query =
          "SELECT backup_id"
        . "  FROM backuplog"
        . " WHERE machine_id = '$machine_id'"
        . "   AND share_id='$share_id'"
        . "   AND backup_date=CURRENT_DATE"
        . "   AND STATUS <> 'S'";
    ($backup_id) = $dbh->exec_single_select($query);

# See if the machine is still connected to the network, if not stop the backup attempt!
    &reset_alarm();

    # Here the "real" backing up begins :)
    if ( $backup_size > 0 ) {
        $start_backup = time;
        my $query;
        my $i = 0;

        PBUtils->logclient( $machine_name, $pid, "info",
            "Backup backup started at $start_backup" );

     # Do the actual backup of the data from the client PC to the backupserver
        if ( !$backup_id )
        {    # We did not try today...create a new entry in the database
            my $query =
                  "INSERT INTO backuplog"
                . " ( machine_id"
                . " , share_id"
                . " , backup_location"
                . " , backup_size"
                . " , skip_size"
                . " , limit_size"
                . " , skip_count"
                . " , vpn"
                . " , transfer_size"
                . " , status)"
                . " VALUES (?, ?, ?, ?, ?, ?, ?, ?, '0', 'I')";
            $dbh->exec_dml(
                $query,           $machine_id,  $share_id,
                $backup_location, $backup_size, $skip_size,
                $limit_size,      $skip_count,  $vpn_enabled
            );
            $query =
                  "SELECT backup_id"
                . "  FROM backuplog"
                . " WHERE machine_id = '$machine_id'"
                . "   AND share_id='$share_id'"
                . "   AND backup_date=CURRENT_DATE"
                . "   AND STATUS <> 'S'";
            ($backup_id) = $dbh->exec_single_select($query);
        }
        else
        { # We already tried today...update the existing entry in the database
            PBUtils->logclient( $machine_name, $pid, "info",
                "Share '$share_id' already backed up today...removing obsoleted folder '$backup_location/$backup_id' now"
            );

#			my $rslt = rmtree ("$backup_location/$backup_id");
#			PBUtils->logclient($machine_name, $pid, "err", "Unable to execute 'rmtree(\"$backup_location/$backup_id\")'") if ($rslt==0 && $!!=0);
            my $query =
                  "UPDATE backuplog"
                . "   SET backup_location = ?"
                . "     , backup_size = ?"
                . "     , skip_size = ?"
                . "     , limit_size = ?"
                . "     , skip_count = ?"
                . "     , vpn = ?"
                . "     , status = 'I'"
                . " WHERE backup_id = ?";
            $dbh->exec_dml( $query, $backup_location, $backup_size, $skip_size,
                $limit_size, $skip_count, $vpn_enabled, $backup_id );
        }

        my $file_count     = 0;
        my $fail_count     = 0;
        my $backup_count   = 0;
        my $pct            = 0;
        my $transfer_size  = 0;
        my $backed_up_size = 0;
        my $lastping       = time;
        my $pct_threshold  = int( $backup_file_count / 100 );
        my $pct_file_count = $pct_threshold;
        foreach $remote_file ( keys %remote_file_list ) {
            my $ref = $remote_file_list{$remote_file};
            next if ( $ref->{status} ne '' && $ref->{status} ne 'b' );

# After each $pinginterval seconds we are going to ping the machine to see if it is still connected to the network, if not we stop the backup attempt!
            if ( time - $lastping > $pinginterval ) {
                PBUtils->logclient( $machine_name, $pid, "info",
                    "Performing Alive ping..." )
                    if $DEBUG;
                &reset_alarm();
                $lastping = time;
            }
            $file_count++;
            $pct_file_count--;
            if ( $pct_file_count <= 0 ) {
                $pct = 100 / $backup_file_count * $file_count;
                my $query =
                      "UPDATE shares"
                    . "   SET progress = CEIL(?)"
                    . " WHERE id = ?";
                $dbh->exec_dml( $query, $pct, $share_id );
                $query =
                      "UPDATE backuplog"
                    . "   SET backup_count = ?"
                    . "     , fail_count = ?"
                    . "     , transfer_size = transfer_size + ?"
                    . " WHERE backup_id = ?";
                $dbh->exec_dml(
                    $query,         $backup_count, $fail_count,
                    $transfer_size, $backup_id
                );
                $pct_file_count = $pct_threshold;
                $transfer_size  = 0;
            }
            PBUtils->logclient( $machine_name, $pid, "info",
                "Now transferring file '$remote_file'" )
                if $DEBUG;
            my $localfile =
                $backup_location . "/current.backup/" . $remote_file;
            if ( $localfile =~ /^(.*)\/[^\/]*$/ ) {
                if ( !-d "$1" ) {
                    my $local_dir = $1;
                    $local_dir =~ s/\`/\\\`/g;
                    my $rslt = system("$mkdir -p \"$local_dir\"");
                    PBUtils->logclient( $machine_name, $pid, "err",
                        "Failed to execute '$mkdir -p \"$local_dir\"'" )
                        unless $rslt == 0;
                    PBUtils->logclient( $machine_name, $pid, "info",
                        "Creating local folder $local_dir" )
                        if $DEBUG;
                }
            }
            if ( $ref->{status} eq '' ) {
                if (   ($current_backup_exists)
                    && ( -f "$backup_location/current.backup/$remote_file" ) )
                {
                    unlink("$backup_location/current.backup/$remote_file");
                }
                my $copyerror;
                open( LOCALFILE, ">$localfile" )
                    || PBUtils->logclient( $machine_name, $pid, "err",
                    "Unable to open '$localfile' for writing" );

                if ( my $fd = $smb->open("smb://$machine_ip/$remote_file") ) {
                    while ( defined( my $block = $smb->read($fd) ) ) {
                        if ( $block eq "-1" && $! != 0 ) {
                            $copyerror = "Error: $!";
                            PBUtils->logclient( $machine_name, $pid, "err",
                                "ERROR DETECTED DURING COPY!!: $copyerror" );
                        }
                        print LOCALFILE $block;
                    }
                    $smb->close($fd);
                }
                else {
                    $copyerror = "Error: $!";
                }
                close(LOCALFILE);

                if ( not $copyerror ) {

                    # Set the correct modification date on the copied file
                    &process_modtime( $remote_file,
                        "$backup_location/current.backup" );
                    $ref->{status} = 'b';
                    $transfer_size  += $ref->{size};
                    $backed_up_size += $ref->{size};
                    $backup_count++;
                }
                else {
                    PBUtils->logclient( $machine_name, $pid, "err",
                        "Unable to backup remote file $remote_file: $copyerror"
                    );
                    $ref->{status} = 'f';
                    $fail_count++;
                }
                $remote_file_list{$remote_file} = $ref;
            }
            else {
                link "$backup_location/$old_backup_id/$remote_file",
                    "$backup_location/current.backup/$remote_file"
                    unless (
                    -f "$backup_location/current.backup/$remote_file" );
            }
        }
        my $error_pct =
            sprintf( "%.2f", 100 / $backup_file_count * $fail_count );
        PBUtils->logclient( $machine_name, $pid, "info",
                  "Successfully backed up "
                . ( 100 - $error_pct )
                . "% of the files" );

        PBUtils->logclient( $machine_name, $pid, "info",
            "Storing backup data in log dbm file ${backup_location}/${backup_id}.dbm"
        );

        # Store the results in the logfile
        # Make sure there is no old log db present
        if ( -e "${backup_location}/${backup_id}.dbm" ) {
            unlink("${backup_location}/${backup_id}.dbm");
        }

        rename(
            "${backup_location}/current.backup.dbm",
            "${backup_location}/${backup_id}.dbm"
        );

        $stop_backup = time;
        PBUtils->logclient( $machine_name, $pid, "info",
            "Backup stopped at $stop_backup" );
        $backup_time = $stop_backup - $start_backup;
        ( my $backup_time_conv ) = PBUtils->convert_sec($backup_time);

        if ( ( 100 - $error_pct ) >= $backupthreshold )
        {    # Set status to S(uccessfull)
            PBUtils->logclient( $machine_name, $pid, "info",
                "Effective backup time: $backup_time_conv" );
            my $query =
                  "UPDATE shares"
                . "   SET backed_up = ?"
                . " WHERE id = ?"
                . "   AND share_name = ?";
            $dbh->exec_dml( $query, $backed_up_size, $share_id, $share_name );
            $query =
                  "UPDATE backuplog"
                . "   SET status = 'S'"
                . "     , backup_time = ?"
                . "     , skip_count = ?"
                . "     , backup_count = ?"
                . "     , fail_count = ?"
                . "	, transfer_size = transfer_size + ?"
                . " WHERE backup_id = ?";
            $dbh->exec_dml(
                $query,      $backup_time,   $skip_count, $backup_count,
                $fail_count, $transfer_size, $backup_id
            );
            my $rslt =
                system(
                "mv $backup_location/current.backup $backup_location/$backup_id"
                );
            PBUtils->logclient( $machine_name, $pid, "err",
                "Failed to execute \"mv $backup_location/current.backup $backup_location/$backup_id\""
            ) unless $rslt == 0;

            PBUtils->logclient( $machine_name, $pid, "info",
                "Backup successful" );
        }
        else {    # Set status to F(ailed)
            my $query =
                  "UPDATE shares"
                . "   SET errcount=errcount+1"
                . "     , backed_up = ?"
                . " WHERE id = ?";
            $dbh->exec_dml( $query, $STATUS{"skipped"}, $share_id );
            $query =
                  "UPDATE backuplog"
                . "   SET status = 'F'"
                . "     , skip_count = ?"
                . "     , backup_count = ?"
                . "     , fail_count = ?"
                . "	, transfer_size = transfer_size + ?"
                . " WHERE backup_id = ?";
            $dbh->exec_dml(
                $query,      $skip_count,    $backup_count,
                $fail_count, $transfer_size, $backup_id
            );
            PBUtils->logclient( $machine_name, $pid, "err", "Backup failed" );
        }
    }
    else {
        my $backed_up;
        $backed_up = $STATUS{"nodiff"};

        $dbh->exec_dml( "UPDATE shares SET backed_up = ? WHERE id = ?",
            $backed_up, $share_id );

        # Set status to E(mpty)
        if ( !$backup_id )
        {    # We did not try today...create a new entry in the database
            my $query =
                  "INSERT INTO backuplog"
                . " ( machine_id"
                . " , share_id"
                . " , backup_location"
                . " , backup_size"
                . " , skip_size"
                . " , limit_size"
                . " , status"
                . " , transfer_size)"
                . " VALUES (?, ?, ?, '0', ?, ?, 'E', '0')";
            $dbh->exec_dml( $query, $machine_id, $share_id, $backup_location,
                $skip_size, $limit_size );
        }
        else
        { # We already tried today...update the existing entry in the database
            my $query =
                  "UPDATE backuplog"
                . "   SET backup_location = ?"
                . "     , backup_size = '0'"
                . "     , backup_count = '0'"
                . "     , fail_count = '0'"
                . "     , skip_size = ?"
                . "     , limit_size = ?"
                . "     , skip_count = ?"
                . "     , status = 'E'"
                . " WHERE backup_id = ?";
            $dbh->exec_dml( $query, $backup_location, $skip_size, $limit_size,
                $skip_count, $backup_id );
        }

        PBUtils->logclient( $machine_name, $pid, "info",
            "Backup successful. No changes found." );
    }
}

sub smbclient_close {
    my ( $share_id, $start_conn ) = @_;
    my ( $stop_conn, $conn_time );

    $stop_conn = time;
    $conn_time = $stop_conn - $start_conn;
    ( my $conn_time_conv ) = PBUtils->convert_sec($conn_time);

    PBUtils->logclient( $machine_name, $pid, "info",
        "SmbClient connection successfully closed at $stop_conn" );
    PBUtils->logclient( $machine_name, $pid, "info",
        "Effective connection time: $conn_time_conv" );

    my $query =
          "UPDATE backuplog"
        . "   SET conn_time = ?"
        . " WHERE share_id = ?"
        . "   AND backup_date = CURRENT_DATE";
    $dbh->exec_dml( $query, $conn_time, $share_id );
}

sub backup_failed {
    my ( $share_id, $text ) = @_;

    my $query =
          "UPDATE shares"
        . "   SET errcount=errcount+1"
        . "     , backed_up = ?"
        . " WHERE id = ?";
    $dbh->exec_dml( $query, $STATUS{"skipped"}, $share_id );

    PBUtils->logclient( $machine_name, $pid, "err", $text );
}

sub skipshare {
    my ($share_id) = @_;

    # If after x times of retry, the share is still not available, disable it
    my $query =
        "SELECT errcount" . "  FROM shares" . " WHERE id = '$share_id'";
    my ($errcount) = $dbh->exec_single_select($query);
    if ( $errcount > $maxretry ) {
        $query =
              "UPDATE shares"
            . "   SET backed_up = ?"
            . "     , errcount = '0'"
            . " WHERE id = ?";
        $dbh->exec_dml( $query, $STATUS{"skippedpermanent"}, $share_id );
    }
}

sub setmachinestatus {
    my $query =
          "SELECT COUNT(*)"
        . "  FROM shares"
        . " WHERE backed_up = '"
        . $STATUS{"skipped"} . "'"
        . "   AND machine_id  = '$machine_id'";
    my ($skipcount) = $dbh->exec_single_select($query);
    $query =
          "SELECT COUNT(*)"
        . "  FROM shares"
        . " WHERE backed_up = '"
        . $STATUS{"skippedpermanent"} . "'"
        . "   AND machine_id  = '$machine_id'";
    my ($failcount) = $dbh->exec_single_select($query);
    $query =
          "SELECT COUNT(*)"
        . "  FROM shares"
        . " WHERE (backed_up > 0 OR backed_up = '"
        . $STATUS{"nodiff"} . "')"
        . "   AND machine_id  = '$machine_id'";
    my ($successcount) = $dbh->exec_single_select($query);
    $query =
          "SELECT COUNT(*)"
        . "  FROM shares"
        . " WHERE machine_id  = '$machine_id'";
    my ($totalcount) = $dbh->exec_single_select($query);

    PBUtils->logclient( $machine_name, $pid, "info",
        "On a total of $totalcount shares there are $skipcount shares skipped, $failcount shares failed and $successcount shares successful"
    );
    if ( $skipcount > 0 || $failcount > 0 )
    {    # Not all shares are properly backed up.
        $dbh->exec_dml( "UPDATE machines SET status = ? WHERE id = ?",
            $STATUS{"skipped"}, $machine_id );
        return 0;
    }
    else {    # All shares of the machine have been backed up successfully
        $dbh->exec_dml( "UPDATE machines SET status = ? WHERE id = ?",
            $STATUS{"successful"}, $machine_id );
        return 1;
    }
}

sub detectvpn {
    my ($machine_ip) = @_;
    my @range     = split /\:/, $vpnrange;
    my $lower     = inet_aton( $range[0] );
    my $upper     = inet_aton( $range[1] );
    my $packed_ip = inet_aton($machine_ip);

    if ( $packed_ip lt $lower || $packed_ip gt $upper ) { return 'N'; }
    else {
        PBUtils->logclient( $machine_name, $pid, "info",
            "Machine $machine_name is connected via vpn." );
        return 'Y';
    }
}

sub reset_alarm {

    # Ping machine to check if it is still alive.
    my $p = Net::Ping->new("icmp");

    # Reset alarm and continue work if it is still alive and kicking
    if ( $p->ping($machine_ip) ) {
        alarm($clienttimeout);
    }
    else {

        # In 1 second we are going to bail out...machine is gone
        alarm(1);
    }
    $p->close();
}

sub alarm_client {

    # Machine is gone...
    my $query =
          "UPDATE shares"
        . "   SET backed_up = '"
        . $STATUS{"skipped"} . "'"
        . "     , errcount=errcount+1"
        . " WHERE machine_id = '$machine_id'"
        . "   AND backed_up<0";
    $dbh->exec_dml($query);
    $query =
        "SELECT id" . "  FROM shares" . " WHERE machine_id = '$machine_id'";
    my $result = $dbh->exec_select($query);
    foreach my $share_id (@$result) {
        &skipshare( @$share_id[0] );
    }
    $dbh->disconnect;
    PBUtils->logclient( $machine_name, $pid, "err",
        "Stopped personalbackupc for machine '$machine_name' due to timeout"
    );
    exit(1);
}

sub quit_client {

    # Client failed to backup...try again later
    my $query =
          "UPDATE shares"
        . "   SET backed_up = '"
        . $STATUS{"skipped"} . "'"
        . " WHERE machine_id = '$machine_id'"
        . "   AND backed_up<0";
    $dbh->exec_dml($query);
    $query =
          "UPDATE machines"
        . "   SET status = '"
        . $STATUS{"skipped"} . "'"
        . " WHERE machine_name = '$machine_name'";
    $dbh->exec_dml($query);
    $dbh->disconnect;
    PBUtils->logclient( $machine_name, $pid, "err",
        "Caught sigterm for personalbackupc for machine '$machine_name'" );
    exit(1);
}

$dbh->disconnect;

# Client normally finished
PBUtils->logclient( $machine_name, $pid, "info",
    "Stopped personalbackupc for machine '$machine_name'" );
exit(0);