Benutzerkontingent mit PHP in Linux zurückgeben

1. Verwenden Sie crontab -e, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben
2. Verwenden Sie den Befehl repquota -a, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben
3. Verwenden Sie den Befehl du -bs, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben
4. Verwenden Sie MySQL-Kontingent, um das Benutzerkontingent mit PHP in Linux OS zurückzugeben
5. Verwenden Sie die Funktion imap_get_quota, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben

Benutzerkontingent ist ein Begriff für die Anzeige der Festplattennutzung und der Beschränkungen eines bestimmten Benutzers im Linux-Betriebssystem. In diesem Tutorial lernen Sie verschiedene Möglichkeiten kennen, wie Sie mit PHP im Linux-Betriebssystem ein Kontingent erhalten oder an seinen Benutzer zurückgeben können.

Standardmäßig sind Server berechtigt, nur Benutzerkontingente zu drucken, da die anderen Kontingentberichte aller Dateisysteme in /etc/mtab aufgeführt sind, und Sie können rpc.rquotad auf dem Servercomputer aufrufen, um die Informationen für Dateisysteme zu erhalten sind NFS-gemountet.

Es ist wichtig zu lernen, wie man ein oder mehrere Dateisysteme überquotiert, wenn Quota mit einem Nicht-Null-Status beendet wird, und Sie finden Standarddateisysteme meistens unter /etc/mtab und quota.user oder quota.group-Quote Dateien im Dateisystemstamm.

Da Kontingente den Benutzer vor unbeabsichtigtem Missbrauch schützen, die Datenexfiltration minimieren und die Benutzerressourcen vor übermäßiger Nutzung schützen können, sind sie wichtig, um sie zur Verwaltung, Aktualisierung oder Anzeige durch den Benutzer zurückzugeben und den Speicherplatz oder den Speicherplatz zu begrenzen Anzahl der Dateien, die ein Benutzer verwenden oder auf die er zugreifen kann.

Kontingente sind unerlässlich, um den Speicherplatz und die Anzahl der von einem bestimmten Benutzer verwendeten Dateien zu beschränken oder zu verfolgen, und sie werden auf ein bestimmtes Volume oder qtree angewendet.

Es kann ein Szenario sein, in dem Sie SELinux als Anforderung deaktivieren müssen, bevor Sie die Benutzerquote mit PHP zurückgeben, und Sie können dies mit etwas wie [root@managed2 ~]# setenforce 0 tun.

Verwenden Sie crontab -e, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben

Es ist wichtig zu beachten, dass der Benutzer (der Benutzer, der die Kontrolle über den PHP-Code hat) nicht in der Lage ist, externe Befehle auszuführen, um die Benutzerquote auf dem Linux-Betriebssystem zu extrahieren, da er eingeschränkten Zugriff hat, um sie zu erhalten.

Um Zugriff zu erhalten oder die Beschränkungen zum Abrufen von Benutzerkontingenten durch das System zu entfernen, kann der Benutzer die PHP-Konfiguration entsprechend seiner Serverkonfiguration ändern, beispielsweise durch Entfernen von safe_mode,, was ebenfalls unmöglich sein kann, falls der Benutzer eingeschaltet ist Shared Hosting und erfordert den Zugriff durch Kommunikation mit dem Anbieter über einen PHP-Aufruf.

Es ist einfach, PHP-Einschränkungen zu umgehen, indem die Kontingente in einer .txt-Datei in einem externen Cron-Job gesammelt werden, aber dies funktioniert nur für Benutzer, die die Berechtigung zum Einrichten von Cron-Jobs haben oder ordnungsgemäßen Zugriff auf den Server haben.

Sie können den Root-Zugriff und ein lesbares Verzeichnis von Ihrem Webserver mit dem Befehl crontab -e in PHP erhalten, um die Benutzerquote für den Benutzer _username in der Textdatei quota.txt zu speichern, die sich im Ordner des Webservers befindet und aktualisiert wird alle Stunde.

Um diesen Ansatz in einem Benutzerfall anzuwenden, in dem das lesbare Format nicht G ist, entfernen Sie das -s und analysieren Sie die Bytes und konvertieren Sie sie dann in PHP in menschenlesbare Formate.

Der Benutzer muss verstehen, dass der cronjob stündlich ist, und wann immer er auf das Benutzerkontingent zugreift, wird es nicht die Echtzeitstatistiken der Benutzerkontingentinformationen enthalten und einige Inkonsistenzen enthalten; Dies kann jedoch vermieden werden, indem die Quota-Datei des Webservers häufig aktualisiert wird, indem die Häufigkeit des cron erhöht wird.

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <?php

        // use `echo "The time is " . date("h:i:sa");` to implement cronjob in your PHP project

        /* Get User Quota Information
        *
        * add `0 * * * * quota -u -s someusername | grep /dev > /path/to/webserver/quota.txt`
        * to save quota setting
        *
        * prepare user account and array the disk space information by ascertaining the available space on its quota
        * and the space used and the space free to use by a specific user
        *
        * @param string $_user The system user name
        *
        * @return array
        */

        function get_QuotaInfo_User($_user) {
            $user_quota = exec("quota -s -u ".$_user);            // query server
            $user_quota = preg_replace("/[\s-]+/", ' ', $user_quota); // clear spaces
            $arr = explode(' ', $user_quota);

            $_free_space = str_replace('M', '', $arr[3]) - str_replace('M', '', $arr[2]);

            return array(
            "total" => $arr[3],
            "used"  => $arr[2],
            "free"  => $_free_space.'M'
            );

        }

        /*
         * you can write this in your php project to return or show the file containing the user quota

          $user_quota_file_txt = file_get_contents("quota.txt");
          $user_quota_array = explode("   ",$user_quota_file_txt);
          function user_quota_exe($str){
            return intval(substr_replace($str, "", -1));
          }

          echo "total quota: ". $user_quota_array[4]."<br>";
          echo "used: ". $user_quota_array[3]."<br>";
          $free =(user_quota_exe($user_quota_array[4]))-user_quota_exe($user_quota_array[3]);
          echo "free: " . $free . "G";

        */

        ?>
    </body>
</html>

Ausgang:

* display text from the `quota.txt` file

Verwenden Sie den Befehl repquota -a, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben

Es ist ein Linux-Befehl, um einen Benutzerkontingentbericht über die Speichernutzung zurückzugeben, und Sie können dies in PHP übernehmen. Der wichtigste Befehl zum Bearbeiten von Kontingenten ist jedoch edquota, mit dem Sie täglich kritische Kontingentdateien wie /etc/fstab bearbeiten können.

Installieren Sie das Tool quota mit dem Befehl yum install quota, akzeptieren Sie eventuell notwendige Abhängigkeiten und lassen Sie die Installation abschliessen. Verwenden Sie danach quotacheck -cu /home, um die Datenbankdatei zu erstellen, und führen Sie diesen Befehl erneut aus, wobei Sie -c durch -av ersetzen (der neue Befehl sieht wie quotacheck -avu aus), wobei -a dies tut Überprüfen Sie alle lokal gemounteten, Quota-aktivierten Partitionen und -v verwendet die ausführliche Ausgabe.

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <?php

        function execCommand($command, $log) {

            if (substr(php_uname(), 0, 7) == "Windows")
            {
                //windows
                // write alternative command for Windows
            }
            else
            {
                //linux
                shell_exec( $command . "repquota -a" );
            }

            // or
            /*

            shell_exec( $command . "repquota -a" ); // just use this line in your code

            */

            return false;
        }

        ?>
    </body>
</html>

Ausgang:

* it will run the `repquota -a` command in PHP code and show the user quota

Benutzer mit nicht privilegiertem Zugriff auf Linux-Server mit gemeinsam genutztem MySQL- und PHP-Hosting können den Befehl sudo -u ausführen, um ein Benutzerkontingent zu erhalten. Sie können dieses Privileg in der Datei sudoers gewähren und diesen Befehl als nicht privilegierter Benutzer ausführen.

Es ähnelt # repquota -a und # repquota /home, um alle konfigurierten Quotas bzw. Quotas auf einer bestimmten Partition anzuzeigen. Darüber hinaus können Sie Linux-Befehle wie # quota -u user und # quota -g group verwenden, um Kontingente anzuzeigen, die für einen bestimmten Benutzer oder eine bestimmte Benutzergruppe gelten.

Verwenden Sie den Befehl du -bs, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben

Da PHP keine Kontingente ausgeben kann, brauchen Sie einen einfacheren Weg, um die Linux-Befehle auszunutzen, und die Verwendung von explode ist ein perfektes Beispiel für das Teilen eines Strings durch einen String, um Ihren String in PHP in ein Array von Strings umzuwandeln. Sie können jedoch crontable verwenden, um Kontingente nach /temp auszugeben und mit etwas wie $var = exec("cat /tmp/quotas | grep domz | tail -n 1 | awk '{print $4}'") abzurufen. ; in PHP.

Darüber hinaus erfordert die Arbeit mit MySQL zur Rückgabe von Benutzerkontingenten einen anderen Ansatz. Es überprüft die Größe jeder Datenbank und widerruft die INSERT- und CREATE-Privilegien für die Datenbanken, die die angegebene Größenbeschränkung überschreiten.

Da das Kontingent eine Datenbank und nicht benutzerbasiert ist, funktioniert es nicht für Benutzer mit globalen Privilegien, aber in den meisten Umgebungen werden Privilegien in der "db"-Tabelle vergeben, die in PHP mit MySQL geändert werden kann.

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <?php

        $conn_server = $db_host;
        $conn_user = $db_user;
        $user_passwrd = $db_pass;
        $conn_database = "root_cwp";

        // Create a connection
        $conn = new mysqli($conn_server, $conn_user, $user_passwrd, $conn_database);

        class user_quota_spaceused
        {
            private $conn;

            public function __construct($conn)
            {
                $this->conn = $conn;
            }

            public function calculate()
            {
                $quota['home'] = $this->user_homeQuota();
                $quota['mysql'] = $this->user_MySQL_Quota();

                return $quota;
            }

            public function user_homeQuota()
            {
                $user_quota = shell_exec("du -bs /home/*");
                $userQuota_all = explode("\n", $user_quota);

                $quota = [];
                foreach ($userQuota_all as $user_homeQuota_info) {
                    if (!empty($user_homeQuota_info)) {
                        $user_quotaInfo = explode('/', trim($user_homeQuota_info), 2);
                        $conn_user = trim(str_replace('home/', '', $user_quotaInfo[1]));
                        $user_quota = trim($user_quotaInfo[0]);
                        $quota[$conn_user] = (int) $user_quota;
                    }
                }
                return $quota;
            }

            public function user_MySQL_Quota()
            {
                $com_getallQuota = shell_exec("du -bs /var/lib/mysql/*");
                $userQuota_rows = explode("\n", $com_getallQuota);

                $quota = [];
                foreach ($userQuota_rows as $infoQuota_row) {
                    if (!empty($infoQuota_row)) {
                        $quotaInfo_user = explode('/', trim($infoQuota_row), 2);
                        $userQuota_file = trim($quotaInfo_user[0]);
                        $database_name = trim(str_replace('var/lib/mysql/', '', $quotaInfo_user[1]));
                        $explodedDatabase_name = explode('_', trim($database_name), 2);
                        $conn_quotaUser = $explodedDatabase_name[0];

                        if (isset($explodedDatabase_name[1])) {
                            $conn_user_database = $explodedDatabase_name[1];
                        };

                        if (isset($quota[$conn_quotaUser])) {

                            if (isset($conn_user_database)) {
                                $quota[$conn_quotaUser]['db'][$conn_user_database] = (int) $userQuota_file;
                            }

                            $quota[$conn_quotaUser]['db_quota'] += (int) $userQuota_file;

                            $quota[$conn_quotaUser]['db_count']++;
                        }
                        else
                        {
                                if (isset($conn_user_database)) {
                                    $quota[$conn_quotaUser]['db'][$conn_user_database] = (int) $userQuota_file;
                                }

                                $quota[$conn_quotaUser]['db_quota'] = (int) $userQuota_file;
                                $quota[$conn_quotaUser]['db_count'] = 1;
                        }
                        unset($conn_user_database);
                    }
                }

                return $quota;
            }
        }

        $cwpUsersQuota = new user_quota_spaceused($conn);
        $quota = $cwpUsersQuota->calculate();

        ?>
    </body>
</html>

Ausgang:

* gets user home and MySQL quota info and shows the user quota info on a webpage table

Verwenden Sie MySQL-Kontingent, um das Benutzerkontingent mit PHP in Linux OS zurückzugeben

Dieses C++-Programm beschreibt den Prozess des Abrufens eines MySQL-Kontingentskripts für einen bestimmten Benutzer mit kostenloser und weitervertreibbarer Software. Weitere Einzelheiten finden Sie in der GNU General License. Erstellen Sie eine Quota-Tabelle für das MySQL-Quotenskript mit CREATE TABLE mit den Variablen Db und Limit.

Das Feld Db speichert die Information, für welche Datenbank Sie die Grösse begrenzen möchten, und das Feld Limit ist die Grössenbegrenzung pro Benutzer in Bytes. Weiterhin wird das exceeded (Exceeded ENUM (Y, N) DEFAULT N NOT NULL, PRIMARY KEY (Db), UNIQUE (Db)) nur intern verwendet und muss initialisiert werden mit N.

#!/user/bin/am -q
<?PHP

    /*
     * Settings
     */

    $host_mysql  = 'localhost';

    // do not change the `$nysql_user` because root access is required
    $user_mysql  = 'root';
    $pass_mysql  = '';

    // to check not just the Db but the Db with the user quota table
    $database_mysql    = 'quotadb';
    $table_mysql = 'quota';

    /*
     * it is restricted to change anything below without a proper understanding
     */

    $conn_debug = 0;

    // connection to MySQL server
    if (!mysql_connect($host_mysql, $user_mysql, $pass_mysql))
    {
        echo "Connection to MySQL-server failed!";
        exit;
    }

    // database selection process
    if (!mysql_select_db($database_mysql))
    {
        echo "Selection of database $database_mysql failed!";
        exit;
    }

    // to check the quota in each entry of the quota table from the selected database
    $query_mysql = "SELECT * FROM $table_mysql;";
    $result = mysql_query($query_mysql);

    while ($db_row = mysql_fetch_array($result))
    {
        $database_quota = $db_row['db'];
        $limit_userquota = $db_row['limit'];
        $exceeded_quota = ($db_row['exceeded']=='Y') ? 1 : 0;

        if ($conn_debug){
            echo "Checking quota for '$database_quota'...
            ";
        }

        $show_mysqlQuery = "SHOW TABLE STATUS FROM $database_quota;";
        $query_result = mysql_query($show_mysqlQuery);

        if ($conn_debug){
            echo "SQL-query is `$show_mysqlQuery`
            ";
        }

        $size_userQuota = 0;

        while ($query_row = mysql_fetch_array($query_result))
        {
            if ($conn_debug)
            {
                echo "Result of query:
                "; var_dump($query_row);
            }

            $size_userQuota += $query_row['Data_length'] + $query_row['Index_length'];
        }

        if ($conn_debug){
            echo "Size is $size_userQuota bytes, limit is $limit_userquota bytes
            ";
        }

        if ($conn_debug && $exceeded_quota){
            echo "Quota is marked as exceeded.
            ";
        }

        if ($conn_debug && !$exceeded_quota){
            echo "Quota is not marked as exceeded.
            ";
        }

        if (($size_userQuota > $limit_userquota) && !$exceeded_quota)
        {
            if ($conn_debug){
                echo "Locking database...
                ";
            }

            // save the information in the quota table
            $user_infoQuery = "UPDATE $table_mysql SET exceeded='Y' WHERE db='$database_quota';";
            mysql_query($user_infoQuery);

            if ($conn_debug)
            {
                echo "Querying: $user_infoQuery
                ";
            }

            // dismissing the CREATE and INSERT privileges for the database
            mysql_select_db('mysql');
            $user_infoQuery = "UPDATE db SET Insert_priv='N', Create_priv='N' WHERE Db='$database_quota';";
            mysql_query($user_infoQuery);

            if ($conn_debug)
            {
                echo "Querying: $user_infoQuery
                ";
            }

            mysql_select_db($database_mysql);
        }

        if (($size_userQuota <= $limit_userquota) && $exceeded_quota)
        {
            if ($conn_debug){
                echo "Unlocking database...
                ";
            }

            // to save info in the user quota table
            $user_infoQuery = "UPDATE $table_mysql SET exceeded='N' WHERE db='$database_quota';";
            mysql_query($user_infoQuery);

            if ($conn_debug){
                echo "Querying: $user_infoQuery
                ";
            }

            // granting the CREATE and INSERT privileges for the database
            mysql_select_db('mysql');
            $user_infoQuery = "UPDATE db SET Insert_priv='Y', Create_priv='Y' WHERE Db='$database_quota';";
            mysql_query($user_infoQuery);

            if ($conn_debug){
                echo "Querying: $user_infoQuery
                ";
            }

            mysql_select_db($database_mysql);
        }
    }
?>

Ausgang:

* Select the MySQL user quota from the MySQL database

Verwenden Sie die Funktion imap_get_quota, um die Benutzerquote mit PHP im Linux-Betriebssystem zurückzugeben

Es hilft Admin-Benutzern, ihre Benutzerkontingenteinstellungen pro Postfach oder Statistiken zur Kontingentnutzung abzurufen. Die Funktion imap_get_quota ist für Admin-Benutzer, und die Nicht-Admin-Benutzerversion dieser Gruppe ist imap_get_quotaroot(), die sie für einen ähnlichen Zweck verwenden können.

Nutzen Sie diese Funktion und fügen Sie $imap für die IMAP- oder Connection-Instanz und $quota_root als Namen in Form von user.name für das Postfach hinzu. Die fertige Funktion sieht in etwa so aus wie imap_get_quota(IMAP\Connection $imap, string $quota_root): array|false, die ein ganzzahliges Array zurückgibt, das das Speicherlimit und die Nutzung für den angegebenen Benutzer enthält.

Die Rückgabewerte dieser Funktion stellen die Gesamtmenge des zulässigen Speicherplatzes für ein bestimmtes Postfach oder einen bestimmten Benutzer (dargestellt durch limit) und die aktuelle Kapazität oder Kapazitätsauslastung des Benutzers (dargestellt durch Nutzung) dar. Es gibt false zurück und zeigt einen Fehler an, falls die Benutzer- oder Postfachinformationen falsch sind oder in jedem anderen Fall, dass die Kapazitätsnutzungsinformationen aus dem Benutzerkontingent nicht abgerufen werden können.

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <?php
            $userQuota_checkMail = imap_open("{imap.example.org}", "admin_mailaddress", "your_password", OP_HALFOPEN)
                or die("Caution! can't connect to the server: " . imap_last_error());

            $accessuserQuota_checkValue = imap_get_quota($userQuota_checkMail, "user.hassankazmi");

            if (is_array($accessuserQuota_checkValue))
            {
                echo "User's usage level: " . $accessuserQuota_checkValue['usage'];
                echo "User's storage limit: " . $accessuserQuota_checkValue['limit'];
            }

            imap_close($userQuota_checkMail);
        ?>

        // use the following PHP example for `imp_get_quota` 4.3 or greater

        /*
        $userQuota_checkMail = imap_open("{imap.example.org}", "admin_mailadmin", "your_password", OP_HALFOPEN)
            or die("Caution! can't connect to the server: " . imap_last_error());

        $accessuserQuota_checkValue = imap_get_quota($userQuota_checkMail, "user.hassankazmi");
        if (is_array($accessuserQuota_checkValue))
        {
            $user_storageQuota_info = $accessuserQuota_checkValue['STORAGE'];
            echo "User's usage level: " .  $user_storageQuota_info['usage'];
            echo "User's storage limit: " .  $user_storageQuota_info['limit'];

            $user_storageQuota_message = $accessuserQuota_checkValue['MESSAGE'];
            echo "User's MESSAGE usage level: " .  $user_storageQuota_message['usage'];
            echo "User's MESSAGE limit: " .  $user_storageQuota_message['limit'];

            /* ...  */
        }

        imap_close($userQuota_checkMail);
        */
    </body>
</html>

Ausgang:

* user quota info from the mailbox

User's usage level: 32.66 GB
User's storage limit: 60 GB

Die ursprünglichen Zugriffs- oder Rückgabemethoden für Benutzerkontingente in PHP sind aus Gründen der Abwärtskompatibilität verfügbar; ab PHP 4.3 steht die Funktion imap_get_quota nur noch Benutzern der Bibliothek c-client2000 oder höher zur Verfügung. Es ist nur eine sinnvolle Funktion, wenn der Benutzeradministrator die imap für Benutzer öffnet; andernfalls wird es nicht funktionieren.

Es ist wichtig zu beachten, dass nach Abschluss des Skripts der Fehler Notice: Unknown bei der Verwendung der imap-Funktionen (Quota root does not exist (errflg=2) oder ähnliche Fehler) angezeigt wird. Rufen Sie die imap_error()-Funktionen auf, bevor Sie den imap-Stream schließen, um den Fehlerstapel zu löschen und keine Fehlermeldungen mehr zu erhalten.

Ausserdem muss Ihr IMAP-Server getquota-fähig sein, damit diese Funktion funktioniert, was Sie überprüfen können, indem Sie sich direkt mit telnet <mail server> <port> anmelden. Verwenden Sie zum Beispiel telnet mail.myserver.com 143 und sehen Sie so etwas wie 0 CAPABILITY.