← Back
Editing: cluserselect.py
# -*- coding: utf-8 -*- # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2019 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT from __future__ import print_function from __future__ import absolute_import from __future__ import division import json import os import sys import uuid import signal import secureio from future.moves import configparser as ConfigParser from stat import S_IRUSR, S_IWUSR, S_IRGRP, S_IROTH from future.utils import iteritems from pathlib import Path import psutil from .clselect import ClSelect from .clselectexcept import ClSelectExcept from clcommon import ClPwd, clcaptain from .clselectprint import clprint from . import utils from clcommon import clcagefs from clcommon.utils import ExternalProgramFailed from clcommon.cpapi import docroot, domain_owner, userdomains from clcommon.cpapi.cpapiexceptions import NoDomain, NoPanelUser try: from clcagefslib.const import BASEDIR from clcagefslib.fs import get_user_prefix from clcagefslib.selector.configure import is_ea4_enabled, read_cpanel_ea4_php_conf, configure_alt_php from clcagefslib.selector.panel.da import da_change_user_php_ini except ImportError: pass try: from clcagefslib.webisolation.jail_utils import get_website_id from clcagefslib.webisolation.config import load_user_config except ImportError: get_website_id = lambda _: None load_user_config = None class ClUserSelect(ClSelect): CAGEFS_PATH = "/var/cagefs" SELECTOR_PATH = "/usr/selector" NATIVE_PATH = SELECTOR_PATH if clcagefs.in_cagefs() else "/usr/share/cagefs-skeleton/usr/selector" CAGEFS_EXCLUDE = "/etc/cagefs/exclude" SELECTOR2_DIR = ".cl.selector/selector.path" def clean_crui_images(self, users=None): """ Creates flags mod_lsapi_reset_me in users' home directories in order to recreate CRIU images when php version/extensions/options have changed For details see LVEMAN-1210 :param users: list of usernames (strings) """ # There is not reliable way to check if CRIU is enabled inside CageFS # So let's always create the "mod_lsapi_reset_me" flag if not clcagefs.in_cagefs() and not os.path.isfile("/var/run/mod_lsapi/criu.enabled"): return for user in users: pw = self._clpwd.get_pw_by_name(user) path = os.path.join(pw.pw_dir, "mod_lsapi_reset_me") if not os.path.isfile(path): previous_user_data = self._change_uid(user) try: clcaptain.write(path) except (OSError, ExternalProgramFailed) as e: raise ClSelectExcept.UnableToSaveData(path, e) finally: ClUserSelect._restore_uid(previous_user_data) @staticmethod def switch_symlink_for_alt_php(version, pw, document_root=None, exit_on_error=True, configure_multiphp=True): """ Switch symlink for alt php. Create .cagefs directory if not created Rerurn True if error has occured """ if not os.path.isdir(BASEDIR) and not clcagefs.in_cagefs(): print("ERROR: CageFS not installed.") if exit_on_error: sys.exit(1) else: return True if configure_multiphp and is_ea4_enabled(): conf = read_cpanel_ea4_php_conf() if conf: try: # get default system php version selected via MultiPHP Manager in cPanel WHM default_php = conf["default"] # LVEMAN-1170: do not configure PHP Selector when system default version is alt-php if not default_php.startswith("ea-php"): print( "ERROR: system default PHP version is alt-php. " "PHP Selector is disabled. Use cPanel MultiPHP manager instead." ) if exit_on_error: sys.exit(1) else: return True except KeyError: pass # configure alt php - create .cagefs dir and create symlink error = configure_alt_php( pw, version, document_root, write_log=False, drop_perm=(os.geteuid() == 0), configure_multiphp=configure_multiphp ) if error and exit_on_error: sys.exit(1) # When setting global version (document_root=None), sync isolated websites # that don't have per-domain PHP Selector enabled so they follow user-level settings if not document_root and load_user_config is not None: isolated_domains = set(load_user_config(pw.pw_name).enabled_websites) # in some tests (e.g selectorctl.backup.robot) user is created just via useradd -> # plesk cpapi raises NoPanelUser try: target_domains = userdomains(pw.pw_name) except NoPanelUser: target_domains = [] for domain, domain_docroot in target_domains: if domain not in isolated_domains: continue configure_alt_php( pw, version, domain_docroot, write_log=False, drop_perm=(os.geteuid() == 0), configure_multiphp=configure_multiphp ) return error def apply_symlinks_rules(self): if self.without_cagefs: print('ERROR: this option does not work in "single user" mode (when CageFS is disabled)') sys.exit(1) if os.geteuid() != 0: print("ERROR: root privileges required") sys.exit(1) users_vers_dict = self.get_user_version_map() for user, version in iteritems(users_vers_dict): print("Processing user", user) pw = self._clpwd.get_pw_by_name(user) ClUserSelect.switch_symlink_for_alt_php(version, pw, exit_on_error=False, configure_multiphp=False) def __init__(self, item="php", exclude_pid_list=None): ClSelect.__init__(self, item) self._clpwd = ClPwd() self._user_excludes = set() if exclude_pid_list: self.exclude_pid_list = exclude_pid_list else: self.exclude_pid_list = [] def get_version(self, user, domain=None, show_native_version=False): """ Returns alternative version for a user @param user: string @return: string """ self._check_user_in_cagefs(user) alt_path = self._compose_user_alt_path(user) if domain: document_root = docroot(domain)[0] alt_path = self._compose_user_alt_path(user, document_root) if not os.path.isdir(alt_path): alt_path = self._compose_user_alt_path(user) native = self._compose_native_info(show_native_version) if not os.path.isdir(alt_path): return native alternatives = self.get_all_alternatives_data() full_path = os.path.join(alt_path, self._item) if not os.path.islink(full_path): return native link_dst = os.readlink(full_path) if self.without_cagefs: if not self._native_contents: self._load_native_contents(self._item) if link_dst == self._native_contents[self._item]: return native if os.path.dirname(link_dst) == self.SELECTOR_PATH: return native try: version = list( filter((lambda i: alternatives[i]["data"][self._item] == link_dst), list(alternatives.keys())) )[0] return (version, alternatives[version]["version"], alternatives[version]["data"][self._item]) except (IndexError, KeyError): return native def create_dir(self, path, user): if not os.path.isdir(path): previous_user_data = self._change_uid(user) try: clcaptain.mkdir(path) except (OSError, ExternalProgramFailed) as e: raise ClSelectExcept.UnableToSaveData(path, e) finally: ClUserSelect._restore_uid(previous_user_data) def create_selector_symlinks(self, user): """ Creates additional directory and symlinks for use in "without CageFS" mode """ homedir = self._clpwd.get_homedir(user) path_in_home = os.path.join(homedir, self.SELECTOR2_DIR) cur_user = self._change_uid(user) self.create_dir(path_in_home, user) self._create_symlink("../php-cli", path_in_home + "/php", check_existence=True) self._create_symlink("../php", path_in_home + "/php-cgi", check_existence=True) self._restore_uid(cur_user) def get_default_version(self): if os.path.isfile(ClSelect.DEFAULTS_PATH): try: return self._dh.get("versions", self._item) except (ConfigParser.Error, IOError, KeyError): return "native" return "native" def set_version_from_backup(self, user): user_backup_path = os.path.join(self._clpwd.get_homedir(user), ".cl.selector", "defaults.cfg") if not os.path.isfile(user_backup_path): self.set_version(user, self.get_default_version()) else: try: dh = self._get_default_config_handler(user_backup_path) self.set_version(user, dh.get("versions", self._item)) except (ConfigParser.Error, IOError, KeyError) as e: print("Error while restoring settings from backup", str(e)) sys.exit(1) def _version_enabled(self, version): """" Checks if version is enabled, a version is considered "enabled" if there is no "state" option in the config. The presence of the "state" option always means it is disabled, regardless of its value. @param version: string @return: bool - True if version is enabled, False otherwise """ if not self._dh.has_option("%s%s" % (self._item, version), "state"): return True else: return False def set_version(self, user, version, domain=None, return_summary=False, show_native_version=False, exit_on_error=True): """ Sets alternative version for a users with the same uid @param user: string @return: None """ if os.geteuid() != 0 and (message := self.get_version_selection_disabled_msg(user)): raise ClSelectExcept.VersionModificationBlocked(message) # This check is needed to prevent setting a disabled version as selected version for a user if not self._version_enabled(version): raise ClSelectExcept.VersionModificationBlocked('Version %s is disabled by administrator' % version) if domain: try: owner = domain_owner(domain) except NoDomain: owner = None if owner != user: raise ClSelectExcept.SelectorException("Domain %s does not belong to user %s" % (domain, user)) data = utils.apply_for_at_least_one_user( self._set_version, self._clpwd.get_names(self._clpwd.get_uid(user)), ClSelectExcept.NoUserSelector, version, domain, return_summary, show_native_version, exit_on_error, ) if return_summary: return data def _set_version(self, user, version, domain=None, return_summary=False, show_native_version=False, exit_on_error=True): """ Sets alternative version for a user @param user: string @return: None """ if self.without_cagefs: previous_user_data = self._change_uid(user) self._check_user_in_cagefs(user) document_root = "" if domain: document_root = docroot(domain)[0] alt_path = self._compose_user_alt_path(user, document_root) if not os.path.isdir(alt_path): if self.without_cagefs or domain: self.create_dir(alt_path, user) else: raise ClSelectExcept.NoUserSelector(user) alternatives = self.get_all_alternatives_data() if version not in alternatives and version != "native": raise ClSelectExcept.NoSuchAlternativeVersion(version) self._remove_alternatives_links(alt_path) pw = self._clpwd.get_pw_by_name(user) if version == "native": if self.without_cagefs: if not self._native_contents: self._load_native_contents(self._item) for item, native_path in iteritems(self._native_contents): self._create_symlink(native_path, alt_path + "/" + item, user, version) else: ini = "php.ini" new_ini_created = False new_ini_path = os.path.join("%s.etc" % (self.NATIVE_PATH,), ini) if os.path.exists(new_ini_path): src = os.path.join("%s.etc" % self.SELECTOR_PATH, ini) dst = os.path.join(alt_path, ini) self._create_symlink(src, dst, user, version) new_ini_created = True for filename in os.listdir(self.NATIVE_PATH): if self._item not in filename: continue if filename.endswith(".ini") and new_ini_created: continue dst = os.path.join(alt_path, filename) src = os.path.join(self.SELECTOR_PATH, filename) self._create_symlink(src, dst, user, version) else: for item, path in iteritems(alternatives[version]["data"]): self._create_symlink(path, os.path.join(alt_path, item), user, version) if self.without_cagefs: ClUserSelect._restore_uid(previous_user_data) else: ClUserSelect.switch_symlink_for_alt_php(version, pw, document_root=document_root, exit_on_error=exit_on_error) self._switch_php_da_isp(user, version) self._reload_processes(user) self._backup_settings(user) if return_summary: return self.get_summary(user, show_native_version) def get_version_selection_disabled_msg(self, username: str) -> str: """ Returns a message indicating that the selection of the PHP version is disabled for the user, based on the configuration file. Args: username (str): The username for which to check the configuration. Returns: str: The message indicating that version selection is disabled, or an empty string if the configuration file does not exist or does not contain the message. """ uid = self._clpwd.get_uid(username) config_file = Path(f"/var/cloudlinux/cl.selector/uids/{uid}/version_selection_conf.json") if not config_file.exists(): return "" try: with config_file.open(encoding="utf-8") as f: config_data = json.load(f) return config_data.get("version_selection_disabled_msg", "") except (OSError, ValueError): return "" def get_summary(self, user, show_native_version=False): """ Returns a summary of available alternative versions for the given user. Only versions that are enabled, default, or selected are included. The label for the "native" version is replaced if show_native_version is True. @param user: str - Username inside CageFS. @param show_native_version: bool - Whether to replace the 'native' version label. @return: tuple of (str, (bool, bool, bool)) - Each entry contains the version name and a tuple with flags: (enabled, default, selected). """ self._check_user_in_cagefs(user) # Retrieve all alternatives data and "native" alternatives = self.get_all_alternatives_data() native_info = self._compose_native_info(show_native_version) summary = {"native": {"enabled": True, "default": False, "selected": False}} alt_versions = sorted(alternatives.keys()) alt_versions.append("native") selected_version = self.get_version(user)[0] # Populate summary with alternative versions for version in alt_versions: if version not in summary: summary[version] = {} summary[version]["enabled"] = self._version_enabled(version) summary[version]["default"] = False summary[version]["selected"] = False try: default_version = self._dh.get("versions", self._item) except (ConfigParser.NoSectionError, ConfigParser.NoOptionError): default_version = "native" try: summary[default_version]["default"] = True summary[selected_version]["selected"] = True except KeyError: raise ClSelectExcept.NoSuchAlternativeVersion(default_version) summary[native_info[0]] = summary.pop("native") alt_versions.remove("native") alt_versions.append(native_info[0]) result = [] # Final list for summary output # Include only versions where at least one flag is True for idx, v in enumerate(alt_versions): if not any((summary[v]["enabled"], summary[v]["default"], summary[v]["selected"])): continue result.append((v, (summary[v]["enabled"], summary[v]["default"], summary[v]["selected"]))) return tuple(result) def change_to_version(self, new_version, current_version): """ Changes users of a supplied version to specified_version @param version: string @param current_version: string """ users = self.list_users(current_version) for user in users: try: self.set_version(user, new_version, exit_on_error=False) except Exception as e: # catch every errors, print it and go to the next user clprint.print_diag("text", {"status": "ERROR", "message": str(e)}) pass self.clean_crui_images(users) def list_users(self, version): """ Returns users of a certain alternative """ data = self.get_version_user_map() if version in data: return data[version] return [] def list_all_users(self): """ Returns all valid system users @return: list """ if self.without_cagefs: from .clselectctlphp import get_cpanel_user return [get_cpanel_user()] return list(self._get_system_users().difference(self._get_user_excludes())) def cagefs_copy_etc(self, user): config = dict() config["init"] = 0 config["reinit"] = 0 config["verbose"] = 0 LIBDIR = "/usr/share/cagefs" sys.path.append(LIBDIR) try: import cagefsctl except ImportError: print("ERROR: CageFS not installed.") sys.exit(1) cagefs_etc_path = os.path.join(BASEDIR, get_user_prefix(user), user, "etc") if not os.path.exists(cagefs_etc_path + "/cl.selector") or not os.path.exists(cagefs_etc_path + "/cl.php.d"): cagefsctl.cpetc_for_user(user, config) def get_user_version_map(self): """ Returns user version map as dict @return: dict """ actual_users = self.list_all_users() data = {} for user in actual_users: try: data[user] = self.get_version(user, False)[0] except ClSelectExcept.NotCageFSUser: continue return data def get_version_user_map(self, user_names=None, domain=None): """ Returns users grouped by version @return: dict """ actual_users = user_names or self.list_all_users() data = {} for user in actual_users: try: version = self.get_version(user, domain, False)[0] if not version in data: data[version] = [] data[version].append(user) except ClSelectExcept.NotCageFSUser: continue return data def _create_symlink(src, dst, user=None, version=None, check_existence=False): """ Creates symlink from src to dst @param src: string @param dst: string @param user: string @param version: string @param check_existence: bool @return: None """ try: if check_existence: if os.path.islink(dst): if os.readlink(dst) != src: os.unlink(dst) else: return else: utils.remove_file_or_dir(dst) clcaptain.symlink(src, dst) except Exception as e: if user is not None and version is not None: raise ClSelectExcept.UnableToSetAlternative(user, version, e) raise ClSelectExcept.SelectorException("Cannot create symlink from %s to %s (%s)" % (src, dst, e)) _create_symlink = staticmethod(_create_symlink) def _get_user_excludes(self): """ Returns list of user excludes @return: list """ if self._user_excludes: return self._user_excludes if not os.path.isdir(self.CAGEFS_EXCLUDE): return set() for item in os.listdir(self.CAGEFS_EXCLUDE): full_item_path = os.path.join(self.CAGEFS_EXCLUDE, item) self._user_excludes.update( set(map((lambda x: x.strip()), utils.read_file_as_string(full_item_path).splitlines())) ) return self._user_excludes def _check_user_in_cagefs(self, user): """ Check that cagefs enabled for user """ if self.without_cagefs: return if clcagefs.in_cagefs(): return LIBDIR = "/usr/share/cagefs" sys.path.append(LIBDIR) try: import cagefsctl except ImportError: print("ERROR: CageFS not installed.") sys.exit(1) try: if not cagefsctl.is_user_enabled(user): raise ClSelectExcept.NotCageFSUser(user) except AttributeError: print("ERROR: CageFS version is unsupported. Please update CageFS.") sys.exit(1) def _remove_alternatives_links(self, path): """ Removes all symlinks from directory @param path: string @return: None """ for filename in os.listdir(path): if self._item not in filename: continue full_path = os.path.join(path, filename) if not os.path.islink(full_path): continue os.unlink(full_path) def _compose_user_alt_path(self, user, document_root=None): """ Composes and returns user alternative directory path @param user: string @return: string """ if self.without_cagefs: homedir = self._clpwd.get_homedir(user) return homedir + "/.cl.selector" uid = str(self._clpwd.get_uid(user)) document_root_id = "" if document_root: document_root_id = get_website_id(document_root) if document_root else "" base = ( os.path.join(self.CAGEFS_PATH, uid[-2:], user, "etc", "cl.selector") if not clcagefs.in_cagefs() else "/etc/cl.selector" ) return os.path.join(base, document_root_id) if document_root_id else base def _get_system_users(self): """ Returns set of system users @return: set """ users_dict = self._clpwd.get_user_dict() return set(users_dict.keys()) def _delete_if_symlink(file_path): """ Deletes file to be written if it is a symlink """ if os.path.islink(file_path): try: os.unlink(file_path) except OSError: raise ClSelectExcept.UnableToSaveData(file_path, "Cannot delete symlink while saving data") _delete_if_symlink = staticmethod(_delete_if_symlink) def _change_uid(self, user): """ Changes to another uid and returns tuple of previous euid and egid @param user: string @return: tuple """ entry = self._clpwd.get_pw_by_name(user) new_uid = entry.pw_uid new_gid = entry.pw_gid cur_euid = os.geteuid() cur_egid = os.getegid() if cur_euid == new_uid: return cur_euid, cur_egid try: os.setegid(new_gid) os.seteuid(new_uid) secureio.set_capability() return cur_euid, cur_egid except OSError as e: raise ClSelectExcept.UnableToChangeToAnotherUser(user, e) def _restore_uid(uid_and_gid): """ Restores changed uid and gid to original ones @param uid_and_gid: tuple @return: None """ if uid_and_gid[0] != os.geteuid(): secureio.set_capability(clear=True) try: os.setegid(uid_and_gid[1]) os.seteuid(uid_and_gid[0]) except OSError as e: raise ClSelectExcept.UnableToChangeToAnotherUser(str(uid_and_gid[0]), e) _restore_uid = staticmethod(_restore_uid) def _write_to_file(self, user, file_contents, file_path, create=True): """ Saves data to file @param user: string @param file_contents: string @param file_path: string @return: None """ previous_user_data = self._change_uid(user) try: if not create and not os.path.exists(file_path): return self._delete_if_symlink(file_path) file_directory = os.path.dirname(file_path) try: # Replace tempfile.mkstemp with str(uuid.uuid4()) dirname = "clseltmp_%s" % str(uuid.uuid4()) temp_path = os.path.join(file_directory, dirname) clcaptain.write(temp_path, "%s\n" % (file_contents,)) except (IOError, OSError, ExternalProgramFailed) as e: try: if os.path.exists(temp_path): os.unlink(temp_path) except: pass raise ClSelectExcept.UnableToSaveData(file_path, e) else: try: mask = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH os.rename(temp_path, file_path) os.chmod(file_path, mask) except OSError: pass finally: ClUserSelect._restore_uid(previous_user_data) def _reload_processes(self, user): """ Reloads user process """ try: next_parent = psutil.Process() for i in range(2): next_parent = next_parent.parent() if next_parent is not None: self.exclude_pid_list.append(next_parent.pid) else: break except psutil.NoSuchProcess: pass try: uid = ClPwd().get_uid(user) except (ClPwd.NoSuchUserException,): # no such user return try: for proc in psutil.process_iter(): try: if uid not in [proc.uids().real, proc.uids().effective] or proc.name().find(self._item) == -1: continue pid = proc.pid except psutil.NoSuchProcess: continue try: if pid not in self.exclude_pid_list: os.kill(pid, signal.SIGHUP) except (OSError,): continue except (OSError, IOError): # psutil reads /proc FS as usual FS, skip read errors pass def _skim_over_extensions(path): """ Get extension names from user extensions file comments """ extensions = [] try: ini = open(path) for line in ini: if line.startswith(";---"): ext = line[4 : line.rfind("---")] extensions.append(ext) ini.close() except (OSError, IOError): pass return extensions _skim_over_extensions = staticmethod(_skim_over_extensions) def _backup_settings(self, user): """ Scans all user settings and backups'em in homedir as INI file @param user: string """ self._check_user_in_cagefs(user) backup_contents = [] user_alt_path = self._compose_user_alt_path(user) user_ext_path = os.path.join(os.path.dirname(user_alt_path), "cl.php.d") alternatives = self.get_all_alternatives_data() user_backup_path = os.path.join(self._clpwd.get_homedir(user), ".cl.selector") if not os.path.isdir(user_backup_path): previous_user_data = self._change_uid(user) try: clcaptain.mkdir(user_backup_path) except (OSError, ExternalProgramFailed) as e: ClUserSelect._restore_uid(previous_user_data) raise ClSelectExcept.UnableToSaveData(user_backup_path, e) ClUserSelect._restore_uid(previous_user_data) user_backup_file = os.path.join(user_backup_path, "defaults.cfg") if os.path.isdir(user_alt_path): version = "[versions]\n%s = %s\n" % (self._item, self.get_version(user)[0]) else: version = "[versions]\n%s = native\n" % (self._item,) backup_contents.append(version) for alt in sorted(alternatives.keys()): if self.without_cagefs: curr_ext_path = user_alt_path + "/alt_php" + alt.replace(".", "") + ".ini" else: curr_ext_path = os.path.join(user_ext_path, "alt-php%s" % ((alt.replace(".", ""),)), "alt_php.ini") extensions = self._skim_over_extensions(curr_ext_path) backup_contents.append("[%s%s]\nmodules = %s\n" % (self._item, alt, ",".join(sorted(extensions)))) self._write_to_file(user, "\n".join(backup_contents), user_backup_file) def _switch_php_da_isp(self, user, version): if self.without_cagefs: return da_change_user_php_ini(user, version)
Save File
Cancel