Devolver cuota de usuario con PHP en Linux
-
Use el
crontab -epara devolver la cuota de usuario con PHP en el sistema operativo Linux -
Use el comando
repquota -apara devolver la cuota de usuario con PHP en el sistema operativo Linux -
Use el comando
du -bspara devolver la cuota de usuario con PHP en el sistema operativo Linux - Use la cuota de MySQL para devolver la cuota de usuario con PHP en el sistema operativo Linux
-
Use la función
imap_get_quotapara devolver la cuota de usuario con PHP en el sistema operativo Linux
Cuota de usuario es un término para mostrar el uso del disco y los límites de un usuario específico en el sistema operativo Linux. En este tutorial, aprenderá diferentes formas de obtener o devolver una cuota a su usuario con PHP en el sistema operativo Linux.
De forma predeterminada, los servidores están autorizados a imprimir solo las cuotas de los usuarios, ya que los demás informes de cuotas de todos los sistemas de archivos se enumeran en /etc/mtab, y puede llamar a rpc.rquotad en la máquina del servidor para obtener la información de los sistemas de archivos que están montados en NFS.
Es esencial aprender a sobrecuota de uno o más sistemas de archivos si la cuota sale con un estado distinto de cero, y en su mayoría encontrará sistemas de archivos predeterminados en /etc/mtab y quota.user o quota.group cuota archivos en la raíz del sistema de archivos.
Dado que las cuotas pueden proteger al usuario del abuso involuntario, minimizan la exfiltración de datos y protegen los recursos del usuario del uso excesivo, es importante devolverlas para que el usuario las gestione, actualice o visualice, así como para limitar la cantidad de espacio en disco o la número de archivos que un usuario puede usar o acceder.
Las cuotas son esenciales para restringir o rastrear el espacio en disco y la cantidad de archivos utilizados por un usuario en particular, y se aplican a un volumen específico o qtree.
Puede ser un escenario en el que tenga que deshabilitar SELinux como requisito antes de devolver la cuota de usuario con PHP, y puede hacerlo con algo como [root@managed2 ~]# setenforce 0.
Use el crontab -e para devolver la cuota de usuario con PHP en el sistema operativo Linux
Lo que es importante considerar es que el usuario (el usuario que tiene control sobre el código PHP) no puede ejecutar comandos externos para extraer la cuota del usuario en el sistema operativo Linux porque tiene acceso restringido para obtenerla.
Para obtener acceso o eliminar las restricciones para obtener la cuota de usuario del sistema, el usuario puede cambiar la configuración de PHP de acuerdo con la configuración de su servidor, por ejemplo, eliminando el modo_seguro, que también puede ser imposible de hacer en caso de que el usuario esté en alojamiento compartido y requiere obtener acceso comunicándose con el proveedor a través de una llamada PHP.
Es fácil eludir las limitaciones de PHP recopilando las cuotas en un archivo .txt en un trabajo cron externo, pero esto solo funciona para los usuarios que tienen permiso para configurar trabajos cron o tienen acceso adecuado al servidor.
Puede obtener el acceso raíz y un directorio legible por su servidor web con el comando crontab -e en PHP para guardar la cuota de usuario para el usuario _username en el archivo de texto quota.txt ubicado en la carpeta del servidor web actualizado cada hora.
Para adoptar este enfoque en un caso de usuario donde el formato legible no es G, elimine los -s y analice los bytes, luego conviértalos a legibles por humanos en PHP.
El usuario debe entender que el cronjob es por hora, y cada vez que acceda a la cuota de usuario, no contendrá las estadísticas en tiempo real de la información de la cuota de usuario y puede contener algunas inconsistencias; sin embargo, se puede evitar actualizando el archivo de cuotas del servidor web con frecuencia aumentando la frecuencia del cron.
<!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>
Producción :
* display text from the `quota.txt` file
Use el comando repquota -a para devolver la cuota de usuario con PHP en el sistema operativo Linux
Es un comando de Linux para devolver un informe de cuota de usuario sobre el uso del almacenamiento, y puede adoptarlo en PHP. Sin embargo, el comando principal para editar cuotas es edquota, que le permite editar archivos de cuotas críticas diarias como /etc/fstab.
Instale la herramienta quota emitiendo el comando yum install quota y acepte las dependencias que puedan ser necesarias, y deje que se complete la instalación. Luego, use quotacheck -cu /home para crear el archivo de base de datos y ejecute este comando nuevamente, reemplazando -c con -av (el nuevo comando se verá como quotacheck -avu) donde -a será verifique todas las particiones locales montadas y habilitadas para cuotas y -v usará la salida detallada.
<!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>
Producción :
* it will run the `repquota -a` command in PHP code and show the user quota
Los usuarios con acceso no privilegiado a servidores Linux con alojamiento MySQL y PHP compartido pueden ejecutar el comando sudo -u para obtener la cuota de usuario. Puede otorgar este privilegio en el archivo sudoers y ejecutar este comando como un usuario sin privilegios.
Es similar a # repquota -a y # repquota /home para mostrar todas las cuotas configuradas y cuotas en una partición específica, respectivamente. Además, puede utilizar comandos de Linux como # cuota -u usuario y # cuota -g grupo para mostrar las cuotas que se aplican a un usuario o grupo de usuarios específico.
Use el comando du -bs para devolver la cuota de usuario con PHP en el sistema operativo Linux
Como PHP no puede generar una cuota, necesita una forma más fácil de explotar los comandos de Linux, y usar explotar es un ejemplo perfecto de dividir una cadena por una cadena para convertir su cadena en una matriz de cadenas en PHP. Sin embargo, puede usar crontable para enviar la cuota a /temp y recuperarla con algo como $var = exec("cat /tmp/quotas | grep domz | tail -n 1 | awk '{print $4}'"); en PHP.
Además, trabajar con MySQL para devolver la cuota de usuario requiere un enfoque diferente. Funciona comprobando el tamaño de cada base de datos y revocando los privilegios INSERTAR y CREAR para las bases de datos que excedan el límite de tamaño dado.
Como la cuota es una base de datos y no está basada en el usuario, no funcionará para los usuarios que tienen privilegios globales, pero en la mayoría de los entornos, los privilegios se otorgan en la tabla "db" que se puede modificar en PHP usando MySQL.
<!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>
Producción :
* gets user home and MySQL quota info and shows the user quota info on a webpage table
Use la cuota de MySQL para devolver la cuota de usuario con PHP en el sistema operativo Linux
Este programa C++ describe el proceso de obtención de secuencias de comandos de cuota de MySQL para un usuario específico utilizando software gratuito y redistribuible, y puede consultar la Licencia general de GNU para obtener más detalles. Cree una tabla de Cuota para el script de cuota de MySQL utilizando CREATE TABLE con las variables Db y Limit.
El campo Db almacena la información para qué base de datos desea limitar el tamaño, y el campo Límite es el límite de tamaño por usuario en bytes. Además, el excedido (Exceeded ENUM (Y,N) DEFAULT N NOT NULL, PRIMARY KEY (Db), UNIQUE (Db)) solo se usa internamente y debe inicializarse con 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);
}
}
?>
Producción :
* Select the MySQL user quota from the MySQL database
Use la función imap_get_quota para devolver la cuota de usuario con PHP en el sistema operativo Linux
Ayuda a los usuarios administradores a recuperar su configuración de cuota de usuario por buzón o estadísticas de uso de cuota. La función imap_get_quota es para usuarios administradores, y la versión de usuario no administrador de este grupo es imap_get_quotaroot(), que pueden usar para un propósito similar.
Utilice esta función e incluya $imap para la instancia IMAP o Connection y $quota_root como nombre en forma de user.name para el buzón. La función finalizada se parecerá a imap_get_quota(IMAP\Connection $imap, string $quota_root): array|false, que devuelve una matriz de enteros que contiene el límite de almacenamiento y el uso para el usuario dado.
Los valores devueltos por esta función representan la cantidad total de espacio permitido para un buzón o usuario en particular (representado por el límite) y la capacidad actual del usuario o el uso de la capacidad (representado por el uso). Devuelve false y muestra un error en caso de que la información del usuario o del buzón sea incorrecta o en cualquier otro caso de falla al recuperar la información de uso de capacidad de la cuota del usuario.
<!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>
Producción :
* user quota info from the mailbox
User's usage level: 32.66 GB
User's storage limit: 60 GB
Los métodos originales de acceso o devolución de cuotas de usuario en PHP están disponibles por razones de compatibilidad con versiones anteriores; a partir de PHP 4.3, la función imap_get_quota solo está disponible para los usuarios de la biblioteca c-client2000 o superior. Solo es una función útil cuando el administrador de usuarios abre el imap para los usuarios; De lo contrario, no funcionará.
Es importante tener en cuenta que aparece el error Aviso: Desconocido al usar las funciones imap (La raíz de la cuota no existe (errflg=2) o errores similares) después de que finaliza el script. Llame a las funciones imap_error() antes de cerrar la secuencia imap para borrar la pila de errores y dejar de recibir notificaciones de errores.
Además, su servidor IMAP debe tener la capacidad de getquota para que esta función funcione, y puede verificar esto iniciando sesión directamente usando telnet <servidor de correo> <puerto>. Por ejemplo, utilice telnet mail.myserver.com 143 y verá algo como 0 CAPACIDAD.
Hassan is a Software Engineer with a well-developed set of programming skills. He uses his knowledge and writing capabilities to produce interesting-to-read technical articles.
GitHub