허용 폴더의 메타데이터만 읽는 탐색 모듈

"""Single-directory metadata for a trusted configured root. No content or execution."""
from pathlib import Path
import os
import stat


class ScopeError(ValueError):
    pass


def _linked(info):
    return stat.S_ISLNK(info.st_mode) or bool(
        getattr(info, 'st_file_attributes', 0) & getattr(stat, 'FILE_ATTRIBUTE_REPARSE_POINT', 0x400))


def _parts(relative):
    if type(relative) is not str or len(relative) > 1000:
        raise ScopeError('RELATIVE_PATH_REQUIRED')
    if relative == '':
        return []
    parts = relative.split('/')
    if (any(ord(c) < 32 for c in relative) or '\\' in relative or ':' in relative
            or any(p in {'', '.', '..'} for p in parts)):
        raise ScopeError('RELATIVE_PATH_REQUIRED')
    return parts


def _root(root):
    p = Path(root)
    if not p.is_absolute():
        raise ScopeError('ABSOLUTE_CONFIGURED_ROOT_REQUIRED')
    try:
        if _linked(p.lstat()) or not p.is_dir():
            raise ScopeError('NORMAL_ROOT_REQUIRED')
        return p.resolve(strict=True)
    except OSError:
        raise ScopeError('ROOT_UNAVAILABLE') from None


def _target(root, relative):
    current = root
    for part in _parts(relative):
        current = current / part
        try:
            if _linked(current.lstat()):
                raise ScopeError('LINK_NOT_ALLOWED')
        except OSError:
            raise ScopeError('TARGET_UNAVAILABLE') from None
    try:
        resolved = current.resolve(strict=True)
    except (OSError, RuntimeError):
        raise ScopeError('TARGET_UNAVAILABLE') from None
    if not resolved.is_relative_to(root):
        raise ScopeError('OUTSIDE_CONFIGURED_ROOT')
    return resolved


def _entry(path, relative):
    result = {'name': path.name, 'path': relative, 'kind': 'unavailable',
              'size': None, 'blocked': True}
    try:
        _parts(relative)
        info = path.lstat()
        if _linked(info):
            result['kind'] = 'link'
        elif stat.S_ISDIR(info.st_mode):
            result.update(kind='directory', blocked=False)
        elif stat.S_ISREG(info.st_mode):
            result.update(kind='file', size=info.st_size, blocked=False)
    except (OSError, ScopeError):
        pass
    return result


def list_metadata(root, relative='', *, offset=0, limit=50):
    """Page a sorted one-level listing; pagination is not an I/O or snapshot bound."""
    if type(offset) is not int or not 0 <= offset <= 1000000:
        raise ScopeError('INVALID_OFFSET')
    if type(limit) is not int or not 1 <= limit <= 100:
        raise ScopeError('INVALID_LIMIT')
    configured = _root(root)
    directory = _target(configured, relative)
    if not directory.is_dir():
        raise ScopeError('DIRECTORY_REQUIRED')
    try:
        rows = [_entry(p, '/'.join(filter(None, (relative, p.name)))) for p in directory.iterdir()]
    except OSError:
        raise ScopeError('DIRECTORY_UNAVAILABLE') from None
    rows.sort(key=lambda x: (x['kind'] != 'directory', x['name'].casefold(), x['name']))
    page = rows[offset:offset + limit]
    end = offset + len(page)
    return {'path': relative, 'entries': page, 'directory_entries_scanned': len(rows),
            'total': len(rows), 'offset': offset, 'next_offset': end if end < len(rows) else None,
            'content_read': False, 'code_executed': False, 'snapshot_stable': False,
            'OS_sandbox_proven': False}


def file_metadata(root, relative):
    configured = _root(root)
    target = _target(configured, relative)
    item = _entry(target, relative)
    if item['blocked'] or item['kind'] != 'file':
        raise ScopeError('REGULAR_FILE_REQUIRED')
    return {**item, 'content_read': False, 'code_executed': False, 'OS_sandbox_proven': False}