^^&&^^

Edit File: initquotas

#!/usr/local/cpanel/3rdparty/bin/perl
# cpanel - initquotas                                Copyright 2011 cPanel, Inc.
#                                                           All Rights Reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited

use strict;
use warnings;

use IO::Handle                      ();
use IPC::Open3                      ();
use Cpanel::ConfigFiles             ();
use Cpanel::Backup::Config          ();
use Cpanel::RcsRecord               ();
use Cpanel::SafeFile                ();
use Cpanel::FileUtils::TouchFile    ();
use Cpanel::FindBin                 ();
use Cpanel::Filesys::Mounts         ();
use Cpanel::SafeRun::Simple         ();
use Cpanel::SafeRun::Errors         ();
use Cpanel::Logger                  ();
use Cpanel::Sys::OS                 ();
use Cpanel::Config::LoadWwwAcctConf ();
use Cpanel::Unix::PID::Tiny         ();
use Cpanel::GenSysInfo              ();
use Cpanel::Quota::Cache            ();
use Cpanel::SysQuota::Cache         ();
use Try::Tiny;

local $| = 1;

my $pidfile = '/var/run/initquotas.pid';
my $upid    = Cpanel::Unix::PID::Tiny->new();

# Check for running instances of initquotas.

if ( !$upid->pid_file($pidfile) ) {
    my $pid = $upid->get_pid_from_pidfile($pidfile);
    print "Another instance of initquotas appears to be running at PID '$pid'.\n";
    exit 1;
}

# Check for running instance of quotacheck.

if ( my $pid = $upid->is_pidfile_running('/var/run/quotacheck.pid') ) {
    print "An instance of quotacheck appears to be running at PID '$pid'.\n";
    exit 1;
}

my $ENABLE_QUOTA  = 1;
my $DISABLE_QUOTA = 0;
my @QUOTA_FILES;
my @ALL_QUOTA_FILES                       = ( 'quota.user', 'aquota.user' );
my $supported_file_system_regex           = 'ext[234]|reiserfs';
my $journaled_supported_file_system_regex = 'ext[34]|reiserfs';
my $logger                                = Cpanel::Logger->new();
my $do_quotacheck                         = ( grep( m/skipquotacheck/i, @ARGV ) || -d '/proc/vz/vzaquota' ) ? 0 : 1;
my $mountkeyword                          = 'remount';

if ( has_quota_support_for_xfs() ) {
    $supported_file_system_regex .= '|xfs';
}

my %cmd = (
    'quota'        => undef,
    'quotaon'      => undef,
    'quotaoff'     => undef,
    'quotacheck'   => undef,
    'convertquota' => undef,
);

my @missing_cmds;
foreach my $cmd_name ( keys %cmd ) {

$cmd{$cmd_name} = Cpanel::FindBin::findbin($cmd_name);
    if ( !( $cmd{$cmd_name} && -x $cmd{$cmd_name} ) ) {

push @missing_cmds, $cmd_name;
    }
}

if ( scalar @missing_cmds ) {
    print "Incomplete quota kit: unable to initialize quotas.\n";
    print 'Missing commands: ', join( ', ', @missing_cmds ), "\n";
    exit 1;
}

chmod oct(4755), $cmd{'quota'};

if ( !-e $Cpanel::ConfigFiles::QUOTA_CONF_FILE ) {
    Cpanel::FileUtils::TouchFile::touchfile($Cpanel::ConfigFiles::QUOTA_CONF_FILE);
    chmod( 0600, $Cpanel::ConfigFiles::QUOTA_CONF_FILE );
}

my @mount_output = split( /\n/, Cpanel::SafeRun::Simple::saferun('mount') );
my $has_filesystems_with_quota = grep( /with\s+quotas|usrj?quota/, @mount_output ) ? 1 : 0;

my $distro                   = Cpanel::Sys::OS::getos();
my $distro_version           = Cpanel::Sys::OS::getreleaseversion();
my $supports_journaled_quota = supports_journaled_quota();

push @QUOTA_FILES, 'aquota.user';
push @QUOTA_FILES, 'quota.user' unless $supports_journaled_quota;

#
# Build up our list of mounts
# @MOUNTS is a list of mounts in /etc/mtab
# @ALL_MOUNTED_FSES includes /proc/mounts as well
#
my @MOUNTS           = _fetch_mounts( \@mount_output );
my @ALL_MOUNTED_FSES = @MOUNTS;
_add_proc_mounts( \@ALL_MOUNTED_FSES );

#
# Make sure virtfs is not mounted.  Die if it is and we cannot unmount it
#
check_for_virtfs_mounts( \@ALL_MOUNTED_FSES );

my $backup_dir_mount_points = get_backup_dir_mount_points();

# Modify fstab as needed
my ( $fses_to_convert_arrayref, $mount_cmds_ref, $need_quotacheck ) = setup_quotas($backup_dir_mount_points);

# Don't run quotacheck if none of our file systems use it.
$do_quotacheck &&= $need_quotacheck;

if ( @$mount_cmds_ref || $do_quotacheck ) {
    local $ENV{'LANG'} = 'C';
    my $quota_off = Cpanel::SafeRun::Errors::saferunnoerror( $cmd{'quotaoff'}, '-a' );

foreach my $line ( split( /\n/, $quota_off ) ) {
        next if $line =~ /no\s+such\s+process/i;
        print "Running quotaoff failed!\n";
        Cpanel::SafeRun::Errors::saferunnoerror( $cmd{'quotaon'}, '-a' );
        exit 1;
    }
}

# Now actually remount the file systems with or without quotas based on the logic above.
# So /etc/fstab matches what is actually going on
foreach my $data ( @{$mount_cmds_ref} ) {
    my ( $cmdref, $fstab, $journaled ) = @{$data}{qw/cmd fstab journaled/};
    my $result = Cpanel::SafeRun::Errors::saferunallerrors( @{$cmdref} );
    if ($result) {
        my $cmd = join( " ", @{$cmdref} );
        print "Warning: mount failure while executing $cmd: $result\n";
        if ($journaled) {
            print "Trying non-journaled quotas instead for $cmdref->[-1]\n";
            _update_fstab_line( \$fstab, $DISABLE_QUOTA, $journaled );
            _update_fstab_line( \$fstab, $ENABLE_QUOTA,  0 );
            rebuild_fstab( sub { $data->{'fstab'} eq $_[0] ? $fstab : $_[0] } );
            $result = Cpanel::SafeRun::Errors::saferunallerrors( @{$cmdref} );
            print "Warning: mount failure while executing $cmd: $result\n" if $result;
        }
        if ($result) {
            print "Disabling quotas for $cmdref->[-1]\n";
            _update_fstab_line( \$fstab, $DISABLE_QUOTA, 0 );
            rebuild_fstab( sub { $data->{'fstab'} eq $_[0] ? $fstab : $_[0] } );
        }
    }
}

if ( !$do_quotacheck ) {
    Cpanel::SafeRun::Errors::saferunnoerror( $cmd{'quotaon'}, '-a' );
    if ( !$need_quotacheck ) {
        print "Quotas have been enabled and updated.\n";
    }
    else {
        print "Quotas have been enabled, however they may not be up to date as quotacheck has been skipped.\n";
    }
    exit 0;
}

purge_quotas($fses_to_convert_arrayref);

run_quota_check();

convert_quotas($fses_to_convert_arrayref);

Cpanel::SafeRun::Errors::saferunnoerror( $cmd{'quotaon'}, '-a' );

reset_quota_caches();

Cpanel::Filesys::Mounts::clear_mounts_cache();

print "Quotas have been enabled and updated.\n";

exit 0;

sub reset_quota_caches {
    Cpanel::SysQuota::Cache::purge_cache();

try {
        Cpanel::Quota::Cache::update_quota_cache_dir();
    };

# No reason to catch as update_quota_cache_dir
    # has already logged the error.
    return;
}

sub purge_quotas {
    my $fses_to_purge_arrayref = shift;

foreach my $mntpoint (@$fses_to_purge_arrayref) {
        _purge_quota_files($mntpoint);
    }
    return;
}

sub convert_quotas {
    my $fses_to_convert_arrayref = shift;

foreach my $mntpoint (@$fses_to_convert_arrayref) {
        Cpanel::SafeRun::Errors::saferunnoerror( $cmd{'convertquota'}, $mntpoint ) unless $supports_journaled_quota;
        _set_quota_file_perms($mntpoint);
    }
    return;
}

sub run_quota_check {
    my $val = Cpanel::SafeRun::Errors::saferunallerrors( $cmd{'quotacheck'}, '--help' );
    print 'Updating Quota Files......';
    if ( $val =~ /quota-format/ || $val =~ /Utility for checking/ ) {
        quotarun( $cmd{'quotacheck'}, '-guvamf', '-F', 'vfsv0' );
        quotarun( $cmd{'quotacheck'}, '-guvamf', '-F', 'vfsold' ) unless $supports_journaled_quota;
    }
    elsif ( $val =~ m/invalid option/mi || $val =~ m/illegal option/mi || $val =~ m/usage: quotacheck/mi ) {
        quotarun( $cmd{'quotacheck'}, '-guva' );
    }
    else {
        quotarun( $cmd{'quotacheck'}, '-Ffguva' );
    }
    print '....Done' . "\n";
    return;
}

sub quotarun {
    my (@CMD) = @_;
    print "\n\t";

my $empty_dir = q{/var/cpanel/empty_directory};
    if ( !-d $empty_dir ) {
        die "Cannot create directory '$empty_dir': $!" unless mkdir( $empty_dir, 0700 );
    }

local $ENV{'LD_PRELOAD'} = "$Cpanel::ConfigFiles::CPANEL_ROOT/lib/quotacheck_virtfs_wrapper.so";

my $qout_fh = IO::Handle->new();
    my $pid = IPC::Open3::open3( '>/dev/null', $qout_fh, $qout_fh, @CMD );
    while ( read( $qout_fh, $_, 1 ) ) {
        s/\n/\n\t/g;
        print;
    }
    print "\n";
    close($qout_fh);
    waitpid( $pid, 0 );
    return;
}

sub _fetch_mounts {
    my ($mount_output_arr_ref) = @_;

if ( !defined $mount_output_arr_ref || ref $mount_output_arr_ref ne 'ARRAY' ) {
        @{$mount_output_arr_ref} = split( /\n/, Cpanel::SafeRun::Simple::saferun('mount') );
    }

my @mounts;
    foreach my $mount_line ( @{$mount_output_arr_ref} ) {
        next if $mount_line =~ m/^(?:proc|procfs|sysfs|devpts|devfs|tmpfs|autofs|usbfs|none)\s/;
        push @mounts, ( split( /\s+/, $mount_line ) )[2];
    }
    return @mounts;
}

sub _purge_quota_files {
    my $mntpoint = shift;
    foreach my $quota_file (@ALL_QUOTA_FILES) {
        if ( -e $mntpoint . '/' . $quota_file ) { unlink( $mntpoint . '/' . $quota_file ) }
    }
}

sub _set_quota_file_perms {
    my $mntpoint = shift;
    foreach my $quota_file (@QUOTA_FILES) {
        if ( -e $mntpoint . '/' . $quota_file ) { chmod 0644, $mntpoint . '/' . $quota_file }
    }
}

sub wall {
    my $wall_txt = shift;
    my $wall_cmd = Cpanel::FindBin::findbin('wall');
    if ( !-x $wall_cmd ) { return; }
    if ( open( my $wall_fh, '|-' ) || exec($wall_cmd ) ) {
        print {$wall_fh} $wall_txt;
        close($wall_fh);
    }
}

#
# Checks to make sure virtfs is not mounted.
# If it is try to kill jailshell to force it to unmount
# Finally bail out if that all fails
#
sub check_for_virtfs_mounts {
    my $all_mounted_fses_ref = shift;

if ( grep( /\/virtfs/, @$all_mounted_fses_ref ) ) {
        print <<'EOM';
Warning virtual file systems are mounted. Quotas may be counted as double
for users who are currently logged in. Please have jailshell users logout
before running quotacheck in the future!

All jailed users will be logged out in 60 seconds!

EOM
        wall("Warning! The system is about to perform quota maintenance.\nAll users will be logged out in 60 seconds.\nPLEASE Do not log back in for 30 minutes, or you may inadvertantly disable your account.\n");
        sleep(60);
        system( 'killall', '-TERM', 'jailshell' );
        sleep(5);

# Clean up virtfs mounts
        system '/usr/local/cpanel/scripts/clear_orphaned_virtfs_mounts', '--errorsonly', '--clearall';

# Need to refresh the 'mount' output as some mounts were supposed to be removed
        @mount_output = split( /\n/, Cpanel::SafeRun::Simple::saferun('mount') );

@$all_mounted_fses_ref = _fetch_mounts( \@mount_output );
        _add_proc_mounts($all_mounted_fses_ref);

if ( grep( /\/virtfs/, @$all_mounted_fses_ref ) ) {
            die "Failed to unmount virtual file system.";
        }
    }
}

#
# Takes an arrayref of mount "lines" and pushes on the contents of /proc/mounts
#
sub _add_proc_mounts {
    my ($mount_array_ref) = @_;
    if ( -r '/proc/mounts' ) {
        if ( open( my $proc_mnt_fh, '<', '/proc/mounts' ) ) {
            while ( my $line = readline $proc_mnt_fh ) {
                chomp $line;
                my ( $device, $mount, $type, undef ) = split( /\s+/, $line, 4 );
                next if !$type || $device eq 'none' || $type =~ m/^(?:proc|procfs|sysfs|devpts|devfs|tmpfs|autofs|usbfs|none)$/ || grep { $_ eq $mount } @{$mount_array_ref};
                push @{$mount_array_ref}, $mount;
            }
            close($proc_mnt_fh);
        }
    }
    return $mount_array_ref;
}

sub rebuild_fstab {
    my ($changeref) = @_;
    Cpanel::RcsRecord::rcsrecord('/etc/fstab');

my @CFILE;
    my $fstab_fh = IO::Handle->new();

if ( !-e '/etc/fstab' ) { $logger->die('Could not edit /etc/fstab'); }
    my $fstablock = Cpanel::SafeFile::safeopen( $fstab_fh, '+<', '/etc/fstab' );
    if ( !$fstablock ) {
        $logger->die('Could not edit /etc/fstab');
    }
    while ( my $fstab_line = readline($fstab_fh) ) {
        push @CFILE, &$changeref($fstab_line);
    }

seek( $fstab_fh, 0, 0 );
    print {$fstab_fh} join( '', @CFILE );
    truncate( $fstab_fh, tell($fstab_fh) );
    Cpanel::SafeFile::safeclose( $fstab_fh, $fstablock );

Cpanel::RcsRecord::rcsrecord('/etc/fstab');
    return;
}

#
# Cycle though the fstab and add usrquota to all supported filesystems
# and remove from filesystems that should not have them
#
sub setup_quotas {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Refactoring this function is a project, not a bug fix

my $backup_dir_mount_points = shift;

my @CFILE;
    my @MOUNT_CMDS;
    my @NEED_CONVERT;
    my $wwwacct_ref = Cpanel::Config::LoadWwwAcctConf::loadwwwacctconf();
    my $home = $wwwacct_ref->{'HOMEDIR'} || '/home';

Cpanel::RcsRecord::rcsrecord('/etc/fstab');

my $fstab_fh = IO::Handle->new();

my $home_dir_mount_point = _get_fs_mountpoint($home);

my $need_quotacheck = 0;

LINE:
    while ( my $fstab_line = readline($fstab_fh) ) {
        if ( $fstab_line =~ /^(\S+)\s*(\S+)/ ) {
            my ( $dsk, $mntpoint, $fstype, $options, $dump, $pass, @opts ) = split( /\s+/, $fstab_line );
            my @options = split( /\s*\,\s*/, $options || '' );
            if ( grep( /^(?:ro|noauto|loop)/, @options ) ) {
                push @CFILE, $fstab_line;
                next LINE;
            }
            if ( grep( /^noquota/, @options ) ) {
                print "Quotas will not be enabled on $mntpoint because the noquota option was specified in the fstab file\n";
                push @CFILE, $fstab_line;
                next LINE;
            }
            my $has_usr_quota = ( $fstab_line =~ /\bu(srj?)?quota\b/ ? 1 : 0 );
            $dsk =~ s/^LABEL=//g;
            if ( $fstab_line =~ /\s*$supported_file_system_regex/ ) {
                foreach my $quota_file (@QUOTA_FILES) {
                    if ( -l $mntpoint . '/' . $quota_file ) {
                        push( @CFILE, $fstab_line );
                        next LINE;    #openvz
                    }
                }

my $use_journaled = $fstab_line =~ /\s*$journaled_supported_file_system_regex/ ? $supports_journaled_quota : 0;
                my $mountpnt_can_do_quota = ( $mntpoint =~ /^(?:\/boot|\/tmp)/ ? 0 : 1 );

$need_quotacheck ||= $fstype ne 'xfs' && $mountpnt_can_do_quota;

#NOTE:: QUOTAS CAN BE ON A BACKUP DISK SINCE ALL FILES ARE ALWAYS OWNED BY ROOT -- HOWEVER IT IS SLOW

if ($mountpnt_can_do_quota) {
                    if ( grep { $mntpoint eq $_ } @{$backup_dir_mount_points} ) {
                        if ( $mntpoint eq '/' ) {
                            print "Warning : Your system does not have a separate filesystem for backups. This may cause performance degradation during the backup process.\n";
                        }
                        else {
                            print "Quotas will not be enabled on $mntpoint to prevent performance degradation.\n";
                            $mountpnt_can_do_quota = 0;
                        }
                    }
                }

if ( !$mountpnt_can_do_quota && $has_usr_quota ) {
                    print "$dsk (removing " . ( $use_journaled ? 'journaled ' : '' ) . "quotas)\n";
                    _update_fstab_line( \$fstab_line, $DISABLE_QUOTA, $use_journaled );
                    push @MOUNT_CMDS, { 'cmd' => [ 'mount', '-o', $mountkeyword, $mntpoint ], 'fstab' => $fstab_line, 'journaled' => $use_journaled };
                }
                elsif ( $mountpnt_can_do_quota && !$has_usr_quota ) {
                    print "$dsk (enabling " . ( $use_journaled ? 'journaled ' : '' ) . "quotas)\n";
                    _update_fstab_line( \$fstab_line, $ENABLE_QUOTA, $use_journaled );
                    push @MOUNT_CMDS, { 'cmd' => [ 'mount', '-o', $mountkeyword, $mntpoint ], 'fstab' => $fstab_line, 'journaled' => $use_journaled };
                }
                else {
                    print "$dsk (already configured quotas = $has_usr_quota).\n";
                }

if ( $mountpnt_can_do_quota && $fstype ne 'xfs' ) {
                    _set_quota_file_perms($mntpoint);
                    foreach my $quota_file (@QUOTA_FILES) {
                        my $quota_file_with_path = $mntpoint eq '/' ? $mntpoint . $quota_file : $mntpoint . '/' . $quota_file;
                        if ( !-e $quota_file_with_path ) {
                            Cpanel::FileUtils::TouchFile::touchfile($quota_file_with_path);
                        }
                    }
                    _set_quota_file_perms($mntpoint);
                    push @NEED_CONVERT, $mntpoint;
                }
            }
        }
        push( @CFILE, $fstab_line );
    }
    seek( $fstab_fh, 0, 0 );
    print {$fstab_fh} join( '', @CFILE );
    truncate( $fstab_fh, tell($fstab_fh) );
    Cpanel::SafeFile::safeclose( $fstab_fh, $fstablock );

Cpanel::RcsRecord::rcsrecord('/etc/fstab');

return ( \@NEED_CONVERT, \@MOUNT_CMDS, $need_quotacheck );
}

# Scans the backup configuraiton for fses that are set to be backup fses that have
# quotas enabled on them and disables them.  Returns a hashref list of backup fses that exist
#
sub get_backup_dir_mount_points {
    my @mountpoints;
    my $backup_dir_ref = Cpanel::Backup::Config::get_backup_dirs();
    foreach my $backup_dir ( @{$backup_dir_ref}, '/backup' ) {
        print "checking out $backup_dir\n";
        my $backup_mount = _get_fs_mountpoint($backup_dir);
        push @mountpoints, $backup_mount;
    }
    return \@mountpoints;
}

sub supports_journaled_quota {
    if ( -d '/proc/vz/vzaquota' ) {
        print "journaled quota support: not available with vzaquota (disabled)\n";
        return 0;
    }
    eval 'require Cpanel::Quota::Filesys; require Quota;';
    if ($@) {
        print "journaled quota support: not available due to load failure (disabled): $@\n";
        return 0;
    }

my $has_jquota = 0;
    my $fs         = Cpanel::Quota::Filesys->new();
    my $paths_ref  = $fs->get_devices_with_quotas_enabled();
    foreach my $dev ( sort keys %$paths_ref ) {
        if ( $paths_ref->{$dev}{'mode'} =~ m{usrjquota}i ) {
            $has_jquota = 1;
            last;
        }
    }

if ( !$has_jquota ) {

# quotacheck uses the kernel version being 2.6.11 or later in order to
        # determine whether it thinks journaled quotas should be enabled.  Since
        # there is no seemingly better solution, use this as a fallback metric.
        require Cpanel::OSSys;

my @uname   = Cpanel::OSSys::uname();
        my @version = map { s/^(\d+)(?:-.*)?$/$1/; /^\d+$/ ? $_ : 0 } split /\./, $uname[2];
        my $ok      = scalar @version >= 3 ? 1 : 0;
        if ( $version[0] < 2 ) {
            $ok = 0;
        }
        elsif ( $version[0] == 2 ) {
            if ( $version[1] < 6 ) {
                $ok = 0;
            }
            else {
                $ok = $version[2] >= 11;
            }
        }

if ( !$ok ) {
            print "journaled quota support: kernel does not support (disabled)\n";
            return 0;
        }
    }
    require Cpanel::LoadFile;
    if ( Cpanel::LoadFile::loadfile('/sbin/quotaon') =~ m/usrjquota/ ) {
        print "journaled quota support: kernel supports, user space tools supports (available)\n";
        return 1;
    }
    else {
        print "journaled quota support: kernel supports, user space tools not updated (disabled)\n";
        return 0;
    }
}

sub _update_fstab_line {
    my ( $fstab_line_ref, $action, $supports_journaled_quota ) = @_;

my ( $device, $mntpoint, $fstype, $options, $dump, $pass, @opts ) = split( /\s+/, $$fstab_line_ref );
    my @options_list = split( m/\s*,\s*/, $options );

if ( $action == $DISABLE_QUOTA ) {
        @options_list = grep( !m/(?:quota|jqfmt)/, @options_list );
        push @options_list, 'defaults' if scalar @options_list == 0;
    }
    else {
        @options_list = grep( !m/(?:u(srj?)?quota|jqfmt)/, @options_list );
        if ($supports_journaled_quota) {
            @options_list = grep( !m/^defaults$/, @options_list );    #defaults seems to cause usrjquota to break on some systems
            push @options_list, 'usrjquota=quota.user', 'jqfmt=vfsv0';
        }
        else {
            unshift @options_list, 'defaults' if !grep( m/^defaults$/, @options_list );
            my $usrquota = 'usrquota';
            $usrquota = 'uquota' if has_quota_support_for_xfs() && $$fstab_line_ref =~ m{\bxfs\b};
            push @options_list, $usrquota;
        }
    }
    $options = join( ',', @options_list );

$$fstab_line_ref = join( "\t", $device, $mntpoint, $fstype, $options, $dump, $pass, @opts ) . "\n";

return 1;
}

sub _get_fs_mountpoint {
    my $path = shift;
    my %fs_for_mountpoint;
    foreach my $fs (@ALL_MOUNTED_FSES) {
        my $fspath = ( split( /\s+/, $fs ) )[0];
        $fs_for_mountpoint{$fspath} = undef;
    }
    my @PATH = split( /\//, $path );
    while (@PATH) {
        my $test_path = join '/', @PATH;
        return $test_path if exists $fs_for_mountpoint{$test_path};
        pop @PATH;
    }
    return '/';
}

sub has_quota_support_for_xfs {

# currently only enable xfs quota support on CentOS 7
    return Cpanel::GenSysInfo::get_rpm_distro_version() == 7;
}