File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/clcommon

opt / cloudlinux / venv / lib / python3.11 / site-packages / clcommon /

?? ..
?? __init__.py(1.37 KB)
?? __pycache__
?? clcagefs.py(10.99 KB)
?? clcaptain.py(1.96 KB)
?? clconfig.py(1.68 KB)
?? clconfpars.py(12.09 KB)
?? clcustomscript.py(1.16 KB)
?? cldebug.py(905 B)
?? clemail.py(1.65 KB)
?? clexception.py(1.14 KB)
?? clfunc.py(6.47 KB)
?? clhook.py(3.86 KB)
?? cllog.py(1.45 KB)
?? cloutput.py(471 B)
?? clproc.py(4.05 KB)
?? clpwd.py(7.74 KB)
?? clquota.py(1.27 KB)
?? clsec.py(657 B)
?? clwpos_lib.py(16.6 KB)
?? const.py(277 B)
?? cpapi
?? evr_utils.py(3.55 KB)
?? features.py(5.01 KB)
?? group_info_reader.py(5.29 KB)
?? lib
?? lock.py(1.02 KB)
?? mail_helper.py(4.45 KB)
?? mysql_lib.py(5.84 KB)
?? php_conf_reader.py(9.77 KB)
?? public_hooks
?? sysctl.py(7.61 KB)
?? ui_config.py(3.12 KB)
?? utils.py(32.91 KB)
?? utils_cmd.py(2.71 KB)

Editing: php_conf_reader.py

# -*- coding: utf-8 -*-

# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT
#

import copy
import re

class PhpConfBaseException(Exception):
    """Base class for all php.conf exceptions"""
    def __init__(self, message):
        super().__init__(message)

class PhpConfReadError(PhpConfBaseException):
    def __init__(self, message=None):
        if message is None:
            message = "File open/read error"
        super().__init__(message)

class PhpConfLoadException(PhpConfBaseException):
    def __init__(self, line_num, reason):
        message = f"Error at line {line_num}: {reason}. Please see " \
            "http://docs.cloudlinux.com/index.html?custom_php_ini_options.html"
        super().__init__(message)

class PhpConfNoSuchAlternativeException(PhpConfBaseException):
    def __init__(self, version):
        self.php_version = version
        message = f'No such alternative version ({version})'
        super().__init__(message)

# For unit tests
def _open(file_name):
    return open(file_name, mode='rb')

class PhpConfReader:
    """
    Class for read and parse /etc/cl.selector/php.conf
    During read this file, its syntax check is performed
    Contains methods for get its data for selectoctl and cagefsctl utilities in required formats
    """
    DIRECTIVES_LIST = ['Directive', 'Default', 'Type', 'Comment', 'Range', 'Remark']
    TYPES_LIST = ['value', 'list', 'bool']

def __init__(self, phpconf_path):
        self.phpconf_path = phpconf_path
        # /etc/cl.selector/php.conf contents as dictionary
        # Example:
        # { 'safe_mode': {'Default': 'Off', 'Comment': 'Enables PHP safe mode.',
        #                 'Remark': '<5.4.0', 'Type': 'bool'},
        #   'file_uploads': {'Default': 'On', 'Comment': 'Allows uploading files over HTTP.',
        #                    'Type': 'bool'}
        # }
        self._php_conf = None

def _read_file(self):
        """
        Reads file and returns its content
        :return: List of filelines
        """
        try:
            f = _open(self.phpconf_path)
            conf_lines = f.readlines()
            f.close()
            return conf_lines
        except (OSError, IOError) as e:
            # Open/read error
            raise PhpConfReadError(e.strerror) from e

def _php_conf_load(self):
        data = {}
        conf_lines = self._read_file()
        try:
            directive = None
            current_section = None
            # Analyze lines
            for line_num, line in enumerate(conf_lines, start=1):
                # line example: 'Directive = upload_max_filesize'
                line = line.strip().decode('utf-8', "ignore")
                # pass comments
                if line.startswith('#'):
                    continue
                # Empty line - separator between directives
                if len(line) == 0:
                    directive = None
                    current_section = None
                    continue
                if '=' not in line:
                    # Separator = not found in line - error
                    raise PhpConfLoadException(line_num, "Required separator = not found")
                line_parts = line.split('=', 1)
                directive_name = line_parts[0].strip()
                directive_value = line_parts[1].strip()
                if directive_name not in self.DIRECTIVES_LIST:
                    # Invalid directive
                    raise PhpConfLoadException(line_num, f"Unknown directive '{directive_name}' found")
                if not directive and directive_name != 'Directive':
                    # No current directive and some other directive found - error
                    raise PhpConfLoadException(line_num, f"'{directive_name}' found, but no 'Directive' before it")
                if directive_name == 'Directive':
                    if directive:
                        # 'Directive' duplicate
                        raise PhpConfLoadException(line_num, f"Directive '{directive_name}' duplicate")
                    # Save current directive name and create placeholder for diirective data
                    directive = directive_value
                    current_section = directive_value
                    data[current_section] = {}
                else:
                    if directive_name in data[current_section]:
                        # Directive already present
                        raise PhpConfLoadException(line_num, f"Directive '{directive_name}' duplicate")
                    if directive_name == 'Type' and directive_value not in self.TYPES_LIST:
                        raise PhpConfLoadException(line_num,
                                                   f"Directive is Type, but it value '{directive_value}' is invalid")
                    data[current_section][directive_name] = directive_value
            # Successfull end
            self._php_conf = data
        except PhpConfLoadException as e:
            # Parsing error
            raise e
        except Exception as e:
            raise PhpConfBaseException(e) from e

def get_config_for_selectorctl(self, php_version, php_versions_map):
        """
        Retrives php.conf for selectorctl needs
        :param php_version: PHP version to filter options
        :param php_versions_map: Short to full PHP version map. Example: {'4.4', '4.4.9'}
        :return: dict
        Example:
            {'file_uploads': {'default': 'On',
                              'comment': 'Allows uploading files over HTTP.',
                              'type': 'bool'},
             'max_execution_time': {'default': '30',
                                    'comment': 'The maximum time in seconds a script is allowed to run '
                                               'before it is terminated.',
                                    'type': 'value'},
            }
        """
        # if config not loaded - load it
        if not self._php_conf:
            self._php_conf_load()
        out_dict = {}
        for directive_name, directive_data in self._php_conf.items():
            # directive_data example:
            # { 'Default': 'Off', 'Comment': 'Enables PHP safe mode.',
            #   'Remark': '<5.4.0', 'Type': 'bool'}
            # if directive has Remark attribute, compare version with supplied and pass if need
            if 'Remark' in directive_data and not self._check_version(directive_data['Remark'],
                                                                      php_version, php_versions_map):
                continue
            out_dict[directive_name] = {}
            if 'Default' in directive_data:
                out_dict[directive_name]['default'] = directive_data['Default']
            if 'Comment' in directive_data:
                out_dict[directive_name]['comment'] = directive_data['Comment']
            if 'Type' in directive_data:
                out_dict[directive_name]['type'] = directive_data['Type']
            if 'Range' in directive_data:
                out_dict[directive_name]['range'] = directive_data['Range']
        return out_dict

def get_config_for_cagefsctl(self):
        """
        Retrives php.conf for selectorctl needs
        :return: dict
        Example:
            {'safe_mode': {'Remark': '<5.4.0', 'Type': 'bool'},
             'file_uploads': {'Type': 'bool'}
            }
        """
        # if config not loaded - load it
        if not self._php_conf:
            self._php_conf_load()
        out_dict = {}
        for directive_name, directive_data in self._php_conf.items():
            out_dict[directive_name] = copy.deepcopy(directive_data)
            if 'Comment' in out_dict[directive_name]:
                del out_dict[directive_name]['Comment']
        return out_dict

@staticmethod
    def _check_version(test, version, php_versions_map):
        """
        Compares version in use and version required by PHP feature
        and return true if PHP feature satisfies
        :param test: Condition to filter from php.conf ('Remark' option value), such as <5.4.0
        :param version: PHP Verson to check filter matching, such as 5.3
        :param php_versions_map: Short to full PHP version map. Example: {'4.4': '4.4.9'}
        :return: bool: true - condition true, false - else
        """
        # if test has 2 section, add third
        if len(test.split('.')) == 2:
            test += '.0'
        patt = re.compile(r'([<>=]{1,2})?(\d+\.\d+\.\d+)\.?')
        m = patt.match(test)
        if not m:
            raise PhpConfNoSuchAlternativeException(test)
        action = m.group(1)
        test_int = PhpConfReader._full_version_string_to_int(m.group(2), action)
        version_int = PhpConfReader._full_version_string_to_int(php_versions_map[version], action)
        if action == r'<' and version_int < test_int:
            return True
        if action == r'<=' and version_int <= test_int:
            return True
        if action == r'>' and version_int > test_int:
            return True
        if action == r'>=' and version_int >= test_int:
            return True
        if not action or action == r'=':
            if version_int == test_int:
                return True
        return False

@staticmethod
    def _full_version_string_to_int(s_ver_full, action):
        """
        Convert version string (such as '5.3.29') to int (10653)
        :param s_ver_full: PHP version string. Only full, 3-section versions are allowed
        :param action: Compare type. If None or '=' function will not use third section from version
        :return: integer
        """
        v_array = [int(x) for x in s_ver_full.split('.')]
        ver_int = v_array[0] << 11 | v_array[1] << 7
        if not action or action == r'=':
            return ver_int
        return ver_int | v_array[2]

X7ROOT File Manager

Editing: php_conf_reader.py

Upload File

Create Folder