FM / fixperms

/usr/lib/fixperms

Name	Size	Mode	Actions
venv/	-	0755	rm
__pycache__/	-	0755	rm
fixperms_base.py	9823	0644	edit dl rm
fixperms_cli.py	4105	0644	edit dl rm
fixperms_cpanel.py	8546	0644	edit dl rm
fixperms_cwp.py	4481	0644	edit dl rm
fixperms_ids.py	3096	0644	edit dl rm
fixperms_main.py	4444	0644	edit dl rm
fixperms_wp3.py	1988	0644	edit dl rm

Edit: /usr/lib/fixperms/fixperms_ids.py (3096B)

"""Handles caching user and group database info in memory"""

import grp
import pwd

class IDCache:
    """Handles caching user and group database info in memory"""

# these lookups are fast, but when looking it up once per file chowned
    # to form verbose output, it adds up

def __init__(self, role: str):
        self._grps = {}
        self._pwds = {}
        self._uid2name = {0: 'root'}
        self._gid2name = {0: 'root'}
        if role != 'WP3':
            self.getgrnam('nobody')
            self.getgrnam('mail')

def getpwnam(self, name: str) -> pwd.struct_passwd:
        """Lookup and cache a struct_passwd by name

Args:
            name (str): user name

Raises:
            KeyError: user not found in /etc/passwd

Returns:
            pwd.struct_passwd: pwd.getpwnam() result
        """
        try:
            return self._pwds[name]
        except KeyError:
            pass
        try:
            val = pwd.getpwnam(name)
        except KeyError as exc:
            raise KeyError(f"The {name!r} user is missing") from exc
        self._pwds[name] = val
        self._uid2name[val.pw_uid] = name
        return val

def getgrnam(self, name: str) -> grp.struct_group:
        """Lookup and cache a struct_group by name

Args:
            name (str): group name

Raises:
            KeyError: group not found in /etc/groups

Returns:
            grp.struct_group: grp.getgrnam() result
        """
        try:
            return self._grps[name]
        except KeyError:
            pass
        try:
            val = grp.getgrnam(name)
        except KeyError as exc:
            raise KeyError(f"The {name!r} group is missing") from exc
        self._grps[name] = val
        self._gid2name[val.gr_gid] = name
        return val

def uid_label(self, uid: int) -> str:
        """Lookup and cache a user name by UID

Args:
            uid (int): user ID

Returns:
            str: user name to display, or string of the uid if it was missing
        """
        assert uid != -1
        try:
            return self._uid2name[uid]
        except KeyError:
            pass
        try:
            val = pwd.getpwuid(uid)
        except KeyError:
            self._uid2name[uid] = str(uid)
            return self._uid2name[uid]
        self._uid2name[uid] = val.pw_name
        self._pwds[val.pw_name] = val
        return self._uid2name[uid]

def gid_label(self, gid: int) -> str:
        """Lookup and cache a group name by GID

Args:
            gid (int): group ID

Returns:
            str: group name to display, or string of the gid if it was missing
        """
        assert gid != -1
        try:
            return self._gid2name[gid]
        except KeyError:
            pass
        try:
            val = grp.getgrgid(gid)
        except KeyError:
            self._gid2name[gid] = str(gid)
            return self._gid2name[gid]
        self._gid2name[gid] = val.gr_name
        self._grps[val.gr_name] = val
        return self._gid2name[gid]

cmd: