xXx

Hexid M1n1 5h3ll MobiLe

opt/cpinst/cpinst/plugins/inode/_[ Not.Writable ]

File://opt/cpinst/cpinst/plugins/inode/functions.php

<?php

/**
 * Security Functions
 */

/**
 * Validate and sanitize directory path to prevent path traversal attacks
 * @param string $path: Input path to validate
 * @param string $user: Current user name
 * @return string: Sanitized and validated path
 * @throws Exception: If path is invalid or outside user scope
 */
function validateAndSanitizePath($path, $user) {
    if (empty($path) || empty($user)) {
        throw new Exception('Path and user cannot be empty');
    }
    
    // Remove any null bytes
    $path = str_replace("\0", '', $path);
    
    // Remove dangerous path traversal sequences
    $path = preg_replace('/\.\.+\//', '', $path);
    $path = str_replace(['../', '..\\', '..'], '', $path);
    
    // Remove any non-standard characters that could be used for attacks
    $path = preg_replace('/[^\w\-_\.\/]/', '', $path);
    
    // Ensure path starts with /home/username
    $userHome = '/home/' . $user;
    
    // If path is relative, make it absolute under user's home
    if (strpos($path, '/') !== 0) {
        $path = $userHome . '/' . $path;
    }
    
    // If path doesn't start with user home, prepend it
    if (strpos($path, $userHome) !== 0) {
        $path = $userHome . $path;
    }
    
    // Resolve real path and validate it's within user's scope
    $realPath = realpath($path);
    $realUserHome = realpath($userHome);
    
    // If realpath fails, the path doesn't exist - that's still okay for some operations
    // but we need to validate the intended path
    if (!$realPath) {
        // For non-existent paths, validate the parent directory structure
        $parentPath = dirname($path);
        $realParentPath = realpath($parentPath);
        
        if ($realParentPath && strpos($realParentPath, $realUserHome) !== 0) {
            throw new Exception('Directory path is outside user scope: ' . $path);
        }
        
        // Return the cleaned path even if it doesn't exist yet
        return $path;
    }
    
    // For existing paths, ensure they're within user scope
    if (strpos($realPath, $realUserHome) !== 0) {
        throw new Exception('Directory path is outside user scope: ' . $path);
    }
    
    return $realPath;
}

/**
 * Check if user has permission to access the directory
 * @param string $path: Directory path
 * @param string $user: Current user name
 * @return bool: True if access is allowed
 */
function checkDirectoryPermission($path, $user) {
    try {
        $validatedPath = validateAndSanitizePath($path, $user);
        
        // Check if directory exists and is readable
        if (!is_dir($validatedPath) || !is_readable($validatedPath)) {
            return false;
        }
        
        return true;
    } catch (Exception $e) {
        return false;
    }
}

/**
 * Log security-related actions (disabled)
 * @param string $user: User name
 * @param string $action: Action performed
 * @param string $path: Path accessed
 * @param string $ip: User's IP address
 * @param bool $success: Whether action was successful
 */
function logSecurityAction($user, $action, $path = '', $ip = '', $success = true) {
    // Logging disabled per user request
    return;
}

/**
 * Check rate limiting for user actions (memory-based, no file storage)
 * @param string $user: User name
 * @param int $maxRequests: Maximum requests allowed per time window
 * @param int $timeWindow: Time window in seconds (default 60 seconds)
 * @return bool: True if request is allowed
 */
function checkRateLimit($user, $maxRequests = 10, $timeWindow = 60) {
    // Use session-based rate limiting (no file storage)
    if (session_status() == PHP_SESSION_NONE) {
        @session_start();
    }
    
    $currentTime = time();
    $sessionKey = 'inode_rate_limit_' . $user;
    
    // Initialize or get existing rate limit data
    if (!isset($_SESSION[$sessionKey])) {
        $_SESSION[$sessionKey] = array();
    }
    
    $rateLimitData = $_SESSION[$sessionKey];
    
    // Clean old entries outside the time window
    $rateLimitData = array_filter($rateLimitData, function($timestamp) use ($currentTime, $timeWindow) {
        return ($currentTime - $timestamp) <= $timeWindow;
    });
    
    // Check if user has exceeded the rate limit
    if (count($rateLimitData) >= $maxRequests) {
        return false;
    }
    
    // Add current request
    $rateLimitData[] = $currentTime;
    
    // Save updated rate limit data to session
    $_SESSION[$sessionKey] = $rateLimitData;
    
    return true;
}

/**
 * Generate CSRF token for form protection (cPanel-compatible version)
 * Uses time-based token that doesn't rely on PHP sessions
 * @return string: CSRF token
 */
function generateCSRFToken() {
    // For cPanel environment, use time-based token with user info
    $currentHour = floor(time() / 3600); // Valid for 1 hour
    $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
    $remoteAddr = $_SERVER['REMOTE_ADDR'] ?? '';
    
    // Create a token based on time, user agent, and IP (for basic security)
    $tokenData = $currentHour . '|' . $userAgent . '|' . $remoteAddr;
    $token = hash('sha256', $tokenData . 'inode_secret_key_2024');
    
    return $token;
}

/**
 * Validate CSRF token (cPanel-compatible version)
 * @param string $token: Token to validate
 * @return bool: True if token is valid
 */
function validateCSRFToken($token) {
    if (empty($token)) {
        return false;
    }
    
    $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
    $remoteAddr = $_SERVER['REMOTE_ADDR'] ?? '';
    
    // Check current hour and previous hour (to handle hour transitions)
    $currentHour = floor(time() / 3600);
    $previousHour = $currentHour - 1;
    
    // Generate valid tokens for current and previous hour
    $currentTokenData = $currentHour . '|' . $userAgent . '|' . $remoteAddr;
    $currentValidToken = hash('sha256', $currentTokenData . 'inode_secret_key_2024');
    
    $previousTokenData = $previousHour . '|' . $userAgent . '|' . $remoteAddr;
    $previousValidToken = hash('sha256', $previousTokenData . 'inode_secret_key_2024');
    
    // Accept token if it matches current or previous hour
    return hash_equals($token, $currentValidToken) || hash_equals($token, $previousValidToken);
}

/**
 * Get all domains for the current user using cPanel UAPI
 * @param bool $debug: Return debug information
 * @return array
 */
function getAllDomains($debug = false)
{
    $domains = array();
    $debugInfo = array();
    
    try {
        require_once '/usr/local/cpanel/php/cpanel.php';
        $cpanel = new CPANEL();
        
        // Get domain information using correct UAPI calls
        $domainInfoResult = $cpanel->uapi('DomainInfo', 'domains_data', array('format' => 'hash'));
        $debugInfo['domain_info_call'] = $domainInfoResult;
        
        // Also store the raw domain data for detailed debugging
        if ($domainInfoResult['cpanelresult']['result']['status'] && !empty($domainInfoResult['cpanelresult']['result']['data'])) {
            $debugInfo['raw_domain_data'] = $domainInfoResult['cpanelresult']['result']['data'];
        }
        
        if ($domainInfoResult['cpanelresult']['result']['status'] && !empty($domainInfoResult['cpanelresult']['result']['data'])) {
            $domainData = $domainInfoResult['cpanelresult']['result']['data'];
            
            // Get main domain
            if (!empty($domainData['main_domain'])) {
                $mainDomain = $domainData['main_domain'];
                $domains[] = array(
                    'domain' => isset($mainDomain['domain']) ? $mainDomain['domain'] : (isset($mainDomain['servername']) ? $mainDomain['servername'] : 'unknown'),
                    'type' => 'main',
                    'path' => '/public_html'
                );
            }
            
            // Get addon domains
            if (!empty($domainData['addon_domains'])) {
                foreach ($domainData['addon_domains'] as $addon) {
                    // Extract path from documentroot or dir field
                    $path = '/public_html'; // default
                    if (isset($addon['documentroot'])) {
                        // Convert full path to relative path
                        $path = str_replace('/home/' . $cpanel->cpanelprint('$user'), '', $addon['documentroot']);
                    } elseif (isset($addon['dir'])) {
                        $path = '/' . ltrim($addon['dir'], '/');
                    }
                    
                    $domains[] = array(
                        'domain' => isset($addon['domain']) ? $addon['domain'] : (isset($addon['servername']) ? $addon['servername'] : 'unknown'),
                        'type' => 'addon',
                        'path' => $path
                    );
                }
            }
            
            // Get subdomains
            if (!empty($domainData['sub_domains'])) {
                foreach ($domainData['sub_domains'] as $subdomain) {
                    // Extract path from documentroot or dir field
                    $path = '/public_html'; // default
                    if (isset($subdomain['documentroot'])) {
                        // Convert full path to relative path
                        $path = str_replace('/home/' . $cpanel->cpanelprint('$user'), '', $subdomain['documentroot']);
                    } elseif (isset($subdomain['dir'])) {
                        $path = '/' . ltrim($subdomain['dir'], '/');
                    }
                    
                    $domains[] = array(
                        'domain' => isset($subdomain['domain']) ? $subdomain['domain'] : (isset($subdomain['servername']) ? $subdomain['servername'] : 'unknown'),
                        'type' => 'subdomain',
                        'path' => $path
                    );
                }
            }
            
            // Get parked domains
            if (!empty($domainData['parked_domains'])) {
                foreach ($domainData['parked_domains'] as $parked) {
                    $domains[] = array(
                        'domain' => $parked,
                        'type' => 'parked',
                        'path' => '/public_html'
                    );
                }
            }
        }
        
        // Alternative approach - try individual UAPI calls with correct module/function names
        if (empty($domains)) {
            // Try to get addon domains using correct module
            $addonResult = $cpanel->uapi('DomainInfo', 'list_domains');
            $debugInfo['list_domains_call'] = $addonResult;
            
            if ($addonResult['cpanelresult']['result']['status'] && !empty($addonResult['cpanelresult']['result']['data'])) {
                foreach ($addonResult['cpanelresult']['result']['data'] as $domain) {
                    $domains[] = array(
                        'domain' => $domain['domain'],
                        'type' => isset($domain['type']) ? $domain['type'] : 'unknown',
                        'path' => isset($domain['document_root']) ? 
                                str_replace('/home/' . $cpanel->cpanelprint('$user'), '', $domain['document_root']) :
                                '/public_html'
                    );
                }
            }
        }
        
    } catch (Exception $e) {
        $debugInfo['exception'] = $e->getMessage();
    }
    
    if ($debug) {
        return array(
            'domains' => $domains,
            'debug' => $debugInfo
        );
    }
    
    return $domains;
}

/**
 * Get directory file counts for the current user
 * @param string $user: Username
 * @return array
 */
function getDirectoryFileCounts($user)
{
    if (empty($user))
        return array();
    
    $result = array(
        'first_level_directories' => array()
    );
    
    // Scan /home/$user/ first level only
    $homeDir = '/home/' . $user;
    if (is_dir($homeDir) && is_readable($homeDir)) {
        $result['first_level_directories'] = scanFirstLevelDirectories($homeDir);
    }
    
    return $result;
}

/**
 * Scan only first level directories and count their files
 * @param string $directory: Directory path to scan
 * @return array
 */
function scanFirstLevelDirectories($directory)
{
    $directoryCounts = array();
    
    // Extract user from directory path for security validation
    $user = '';
    if (preg_match('/\/home\/([^\/]+)/', $directory, $matches)) {
        $user = $matches[1];
    }
    
    try {
        if (!is_dir($directory) || !is_readable($directory)) {
            return $directoryCounts;
        }
        
        $items = scandir($directory);
        if ($items === false) {
            return $directoryCounts;
        }
        
        foreach ($items as $item) {
            // Skip . and ..
            if ($item === '.' || $item === '..') {
                continue;
            }
            
            $fullPath = $directory . '/' . $item;
            
            // Only process directories
            if (is_dir($fullPath)) {
                // Count files in this directory with security validation
                $fileCount = countFilesInDirectory($fullPath, $user);
                
                // Only include directories that have files
                if ($fileCount > 0) {
                    $directoryCounts[] = array(
                        'directory' => $item,
                        'path' => $fullPath,
                        'relative_path' => '/' . $item,
                        'file_count' => $fileCount,
                        'readable' => is_readable($fullPath)
                    );
                }
            }
        }
        
        // Sort by file count (descending)
        usort($directoryCounts, function($a, $b) {
            return $b['file_count'] - $a['file_count'];
        });
        
    } catch (Exception $e) {
        // Return empty array on error
    }
    
    return $directoryCounts;
}

/**
 * Get file counts by domain for the current user
 * @param string $user: Username
 * @return array
 */
function getDomainFileCounts($user)
{
    if (empty($user)) {
        return array();
    }
    
    $result = array();
    $homeDir = '/home/' . $user;
    
    try {
        // Get all domains for this user
        $domains = getAllDomains();
        
        if (empty($domains)) {
            return array();
        }
        
        foreach ($domains as $domain) {
            $fullPath = $homeDir . $domain['path'];
            
            // Check if directory exists and is readable
            if (is_dir($fullPath) && is_readable($fullPath)) {
                $fileCount = countFilesInDirectory($fullPath, $user);
                
                if ($fileCount > 0) {
                    $result[] = array(
                        'domain' => $domain['domain'],
                        'type' => $domain['type'],
                        'path' => $fullPath,
                        'relative_path' => $domain['path'],
                        'file_count' => $fileCount,
                        'readable' => true
                    );
                }
            } else {
                // Include domains even if directory doesn't exist for debugging
                $result[] = array(
                    'domain' => $domain['domain'],
                    'type' => $domain['type'],
                    'path' => $fullPath,
                    'relative_path' => $domain['path'],
                    'file_count' => 0,
                    'readable' => false
                );
            }
        }
        
        // Sort by file count (descending)
        usort($result, function($a, $b) {
            return $b['file_count'] - $a['file_count'];
        });
        
    } catch (Exception $e) {
        // Return empty array on error
    }
    
    return $result;
}

/**
 * Get detailed file counts for a specific domain directory (first level only)
 * @param string $user: Username
 * @param string $domainPath: Full path to domain directory
 * @return array
 */
function getDomainDetailFileCounts($user, $domainPath)
{
    if (empty($user) || empty($domainPath)) {
        return array();
    }
    
    $result = array();
    
    // Check if domainPath is already a full path or relative path
    if (strpos($domainPath, '/home/') === 0) {
        // domainPath is already a full path
        $fullPath = $domainPath;
        $relativePath = str_replace('/home/' . $user, '', $domainPath);
    } else {
        // domainPath is relative, construct full path
        $homeDir = '/home/' . $user;
        $fullPath = $homeDir . $domainPath;
        $relativePath = $domainPath;
    }
    
    try {
        if (!is_dir($fullPath) || !is_readable($fullPath)) {
            return array(
                'error' => 'Directory not accessible: ' . $fullPath,
                'directories' => array()
            );
        }
        
        $items = scandir($fullPath);
        if ($items === false) {
            return array(
                'error' => 'Cannot read directory: ' . $fullPath,
                'directories' => array()
            );
        }
        
        $directories = array();
        
        foreach ($items as $item) {
            // Skip . and ..
            if ($item === '.' || $item === '..') {
                continue;
            }
            
            $itemPath = $fullPath . '/' . $item;
            
            // Only process directories
            if (is_dir($itemPath)) {
                // Extract user from path for security validation
                $pathUser = '';
                if (preg_match('/\/home\/([^\/]+)/', $itemPath, $matches)) {
                    $pathUser = $matches[1];
                }
                
                // Count files in this directory with security validation
                $fileCount = countFilesInDirectory($itemPath, $pathUser);
                
                $directories[] = array(
                    'name' => $item,
                    'path' => $itemPath,
                    'relative_path' => $relativePath . '/' . $item,
                    'file_count' => $fileCount,
                    'readable' => is_readable($itemPath)
                );
            }
        }
        
        // Sort by file count (descending)
        usort($directories, function($a, $b) {
            return $b['file_count'] - $a['file_count'];
        });
        
        $result = array(
            'base_path' => $fullPath,
            'relative_path' => $relativePath,
            'directories' => $directories,
            'total_directories' => count($directories)
        );
        
    } catch (Exception $e) {
        $result = array(
            'error' => 'Exception: ' . $e->getMessage(),
            'directories' => array()
        );
    }
    
    return $result;
}

/**
 * Get second level directories for a specific first level directory
 * @param string $directoryPath: Full path to the first level directory
 * @return array
 */
function getSecondLevelDirectories($directoryPath)
{
    if (empty($directoryPath)) {
        return array();
    }
    
    $result = array();
    
    try {
        if (!is_dir($directoryPath) || !is_readable($directoryPath)) {
            return array(
                'error' => 'Directory not accessible: ' . $directoryPath,
                'directories' => array()
            );
        }
        
        $items = scandir($directoryPath);
        if ($items === false) {
            return array(
                'error' => 'Cannot read directory: ' . $directoryPath,
                'directories' => array()
            );
        }
        
        $directories = array();
        
        foreach ($items as $item) {
            // Skip . and ..
            if ($item === '.' || $item === '..') {
                continue;
            }
            
            $itemPath = $directoryPath . '/' . $item;
            
            // Only process directories
            if (is_dir($itemPath)) {
                // Extract user from path for security validation
                $pathUser = '';
                if (preg_match('/\/home\/([^\/]+)/', $itemPath, $matches)) {
                    $pathUser = $matches[1];
                }
                
                // Count files in this directory (including subdirectories)
                $fileCount = countFilesInDirectory($itemPath, $pathUser);
                
                $directories[] = array(
                    'name' => $item,
                    'path' => $itemPath,
                    'relative_path' => str_replace('/home', '', $itemPath),
                    'file_count' => $fileCount,
                    'readable' => is_readable($itemPath)
                );
            }
        }
        
        // Sort by file count (descending)
        usort($directories, function($a, $b) {
            return $b['file_count'] - $a['file_count'];
        });
        
        $result = array(
            'base_path' => $directoryPath,
            'directories' => $directories,
            'total_directories' => count($directories)
        );
        
    } catch (Exception $e) {
        $result = array(
            'error' => 'Exception: ' . $e->getMessage(),
            'directories' => array()
        );
    }
    
    return $result;
}

/**
 * Get third level directories for a specific second level directory
 * @param string $directoryPath: Full path to the second level directory
 * @return array
 */
function getThirdLevelDirectories($directoryPath)
{
    if (empty($directoryPath)) {
        return array();
    }
    
    $result = array();
    
    try {
        if (!is_dir($directoryPath) || !is_readable($directoryPath)) {
            return array(
                'error' => 'Directory not accessible: ' . $directoryPath,
                'directories' => array()
            );
        }
        
        $items = scandir($directoryPath);
        if ($items === false) {
            return array(
                'error' => 'Cannot read directory: ' . $directoryPath,
                'directories' => array()
            );
        }
        
        $directories = array();
        
        foreach ($items as $item) {
            // Skip . and ..
            if ($item === '.' || $item === '..') {
                continue;
            }
            
            $itemPath = $directoryPath . '/' . $item;
            
            // Only process directories
            if (is_dir($itemPath)) {
                // Extract user from path for security validation
                $pathUser = '';
                if (preg_match('/\/home\/([^\/]+)/', $itemPath, $matches)) {
                    $pathUser = $matches[1];
                }
                
                // Count files in this directory (including subdirectories)
                $fileCount = countFilesInDirectory($itemPath, $pathUser);
                
                $directories[] = array(
                    'name' => $item,
                    'path' => $itemPath,
                    'relative_path' => str_replace('/home', '', $itemPath),
                    'file_count' => $fileCount,
                    'readable' => is_readable($itemPath)
                );
            }
        }
        
        // Sort by file count (descending)
        usort($directories, function($a, $b) {
            return $b['file_count'] - $a['file_count'];
        });
        
        $result = array(
            'base_path' => $directoryPath,
            'directories' => $directories,
            'total_directories' => count($directories)
        );
        
    } catch (Exception $e) {
        $result = array(
            'error' => 'Exception: ' . $e->getMessage(),
            'directories' => array()
        );
    }
    
    return $result;
}

/**
 * Scan a directory and count files in each subdirectory recursively
 * @param string $directory: Directory path to scan
 * @param int $maxDepth: Maximum depth to scan (default: 10)
 * @param int $currentDepth: Current depth (internal use)
 * @param array $excludeDirs: Array of directory names to exclude
 * @return array
 */
function scanDirectoryForFileCounts($directory, $maxDepth = 10, $currentDepth = 0, $excludeDirs = array())
{
    $directoryCounts = array();
    
    try {
        if (!is_dir($directory) || !is_readable($directory) || $currentDepth >= $maxDepth) {
            return $directoryCounts;
        }
        
        $items = scandir($directory);
        if ($items === false) {
            return $directoryCounts;
        }
        
        foreach ($items as $item) {
            // Skip . and ..
            if ($item === '.' || $item === '..') {
                continue;
            }
            
            // Skip excluded directories
            if (in_array($item, $excludeDirs)) {
                continue;
            }
            
            $fullPath = $directory . '/' . $item;
            
            // Only process directories
            if (is_dir($fullPath)) {
                // Extract user from path for security validation
                $pathUser = '';
                if (preg_match('/\/home\/([^\/]+)/', $fullPath, $matches)) {
                    $pathUser = $matches[1];
                }
                
                // Count files in this directory (including subdirectories)
                $fileCount = countFilesInDirectory($fullPath, $pathUser);
                
                // Only include directories that have files and are not just empty containers
                if ($fileCount > 0) {
                    $directoryCounts[] = array(
                        'directory' => $item,
                        'path' => $fullPath,
                        'file_count' => $fileCount,
                        'readable' => is_readable($fullPath),
                        'depth' => $currentDepth + 1
                    );
                    
                    // Recursively scan subdirectories if not at max depth
                    if ($currentDepth < $maxDepth - 1) {
                        $subDirectories = scanDirectoryForFileCounts($fullPath, $maxDepth, $currentDepth + 1, $excludeDirs);
                        $directoryCounts = array_merge($directoryCounts, $subDirectories);
                    }
                }
            }
        }
        
        // Sort by file count (descending) only at root level
        if ($currentDepth === 0) {
            usort($directoryCounts, function($a, $b) {
                return $b['file_count'] - $a['file_count'];
            });
        }
        
    } catch (Exception $e) {
        // Return empty array on error
    }
    
    return $directoryCounts;
}

/**
 * Get file quota information for the current user using cPanel UAPI
 * @param object $cpanel: cPanel object instance
 * @return array
 */
function getFileQuotaInfo($cpanel)
{
    if (empty($cpanel)) {
        return array(
            'success' => false,
            'error' => 'cPanel object is required'
        );
    }
    
    try {
        // Get quota information using UAPI
        $quotaResult = $cpanel->uapi('Quota', 'get_quota_info');
        
        if ($quotaResult['cpanelresult']['result']['status'] && 
            !empty($quotaResult['cpanelresult']['result']['data'])) {
            
            $data = $quotaResult['cpanelresult']['result']['data'];
            
            // Extract inode quota information - try different possible field names
            $inodeUsed = 0;
            $inodeLimit = 0;
            $inodeUnlimited = false;
            
            // Try different field names for inodes used
            if (isset($data['inodes_used'])) {
                $inodeUsed = (int)$data['inodes_used'];
            } elseif (isset($data['inode_used'])) {
                $inodeUsed = (int)$data['inode_used'];
            } elseif (isset($data['files_used'])) {
                $inodeUsed = (int)$data['files_used'];
            }
            
            // Try different field names for inodes limit
            if (isset($data['inodes_limit'])) {
                $inodeLimit = (int)$data['inodes_limit'];
            } elseif (isset($data['inode_limit'])) {
                $inodeLimit = (int)$data['inode_limit'];
            } elseif (isset($data['files_limit'])) {
                $inodeLimit = (int)$data['files_limit'];
            } elseif (isset($data['inode_quota'])) {
                $inodeLimit = (int)$data['inode_quota'];
            }
            
            // Try different field names for unlimited flag
            if (isset($data['inodes_unlimited'])) {
                $inodeUnlimited = (bool)$data['inodes_unlimited'];
            } elseif (isset($data['inode_unlimited'])) {
                $inodeUnlimited = (bool)$data['inode_unlimited'];
            } elseif (isset($data['files_unlimited'])) {
                $inodeUnlimited = (bool)$data['files_unlimited'];
            } elseif ($inodeLimit == 0 || $inodeLimit == -1) {
                $inodeUnlimited = true;
            }
            
            // Calculate usage percentage
            $usagePercent = 0;
            if (!$inodeUnlimited && $inodeLimit > 0) {
                $usagePercent = round(($inodeUsed / $inodeLimit) * 100, 2);
            }
            
            return array(
                'success' => true,
                'inodes_used' => $inodeUsed,
                'inodes_limit' => $inodeLimit,
                'inodes_unlimited' => $inodeUnlimited,
                'usage_percent' => $usagePercent,
                'raw_data' => $data
            );
        } else {
            return array(
                'success' => false,
                'error' => 'Failed to get quota information from cPanel UAPI',
                'raw_response' => $quotaResult
            );
        }
        
    } catch (Exception $e) {
        return array(
            'success' => false,
            'error' => 'Exception: ' . $e->getMessage()
        );
    }
}

/**
 * Count files in a directory recursively (with enhanced security)
 * @param string $directory: Directory path
 * @param string $user: Current user name (for security validation)
 * @return int
 */
function countFilesInDirectory($directory, $user = null)
{
    $count = 0;
    
    try {
        // Security validation if user is provided
        if ($user) {
            try {
                $directory = validateAndSanitizePath($directory, $user);
            } catch (Exception $e) {
                return 0;
            }
        }
        
        if (!is_dir($directory) || !is_readable($directory)) {
            return 0;
        }
        
        // Enhanced security: Double-check the path is safe
        $realDirectory = realpath($directory);
        if (!$realDirectory) {
            return 0;
        }
        
        // Additional safety check: ensure no dangerous characters
        if (preg_match('/[;&|`$]/', $realDirectory)) {
            return 0;
        }
        
        // Use shell command with enhanced security
        $escapedDirectory = escapeshellarg($realDirectory);
        
        // Construct safe command with timeout and resource limits
        $command = 'timeout 30 find ' . $escapedDirectory . ' -type f -print0 2>/dev/null | grep -zc ""';
        
        // Execute with output capture and error handling
        $descriptorspec = array(
            0 => array("pipe", "r"),
            1 => array("pipe", "w"),
            2 => array("pipe", "w")
        );
        
        $process = proc_open($command, $descriptorspec, $pipes);
        
        if (is_resource($process)) {
            fclose($pipes[0]);
            
            $output = stream_get_contents($pipes[1]);
            fclose($pipes[1]);
            
            $error = stream_get_contents($pipes[2]);
            fclose($pipes[2]);
            
            $returnCode = proc_close($process);
            
            // Only accept output if command succeeded
            if ($returnCode === 0 && is_numeric(trim($output))) {
                $count = (int)trim($output);
            } else {
                // Fallback to PHP-based counting for small directories
                $count = countFilesInDirectoryPHP($realDirectory);
            }
        } else {
            // Fallback to PHP-based counting
            $count = countFilesInDirectoryPHP($realDirectory);
        }
        
    } catch (Exception $e) {
        $count = 0;
    }
    
    return $count;
}

/**
 * Fallback PHP-based file counting (safer but slower)
 * @param string $directory: Directory path (already validated)
 * @return int
 */
function countFilesInDirectoryPHP($directory)
{
    $count = 0;
    $maxFiles = 10000; // Prevent memory exhaustion
    
    try {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::LEAVES_ONLY
        );
        
        foreach ($iterator as $file) {
            if ($file->isFile()) {
                $count++;
                
                // Prevent runaway counting
                if ($count >= $maxFiles) {
                    return $maxFiles;
                }
            }
        }
    } catch (Exception $e) {
        // Return partial count if iteration fails
    }
    
    return $count;
}

Your Access Expired	Date. in : 16-09-2025
Regist : 09-12-2024	Expired : 01-12-2027