파일 관리 - Rhymix Documentation

파일 관리¶

라이믹스에서 파일과 첨부파일을 효과적으로 관리하는 방법을 학습합니다.

파일 업로드 기본¶

업로드 설정¶

// config/config.inc.php
$config->file = new stdClass();
$config->file->allowed_extensions = array('jpg', 'jpeg', 'gif', 'png', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'zip');
$config->file->max_file_size = 2 * 1024 * 1024; // 2MB
$config->file->max_upload_size = 10 * 1024 * 1024; // 10MB 총합
$config->file->image_quality = 85; // JPEG 품질
$config->file->watermark = false;

게시판별 파일 설정¶

// 게시판 설정에서 파일 업로드 제한
$module_config = new stdClass();
$module_config->use_file_upload = 'Y';
$module_config->allowed_filesize = 5 * 1024 * 1024; // 5MB
$module_config->allowed_attach_count = 3; // 최대 3개 파일
$module_config->allowed_extensions = 'jpg,png,gif,pdf,doc,hwp';

파일 업로드 인터페이스¶

기본 파일 업로드 폼¶

<!-- 기본 파일 업로드 -->
<div class="file-upload-area">
    <label for="file_upload">파일 첨부</label>
    <input type="file" id="file_upload" name="files[]" multiple 
           accept=".jpg,.jpeg,.png,.gif,.pdf,.doc,.docx,.hwp">

    <div class="upload-info">
        <p>최대 파일 크기: 5MB</p>
        <p>허용 확장자: jpg, png, gif, pdf, doc, docx, hwp</p>
        <p>최대 {$module_info->allowed_attach_count}개 파일 업로드 가능</p>
    </div>
</div>

<!-- 업로드된 파일 목록 -->
<div id="uploaded-files" class="uploaded-files">
    <!-- JavaScript로 동적 생성 -->
</div>

드래그 앤 드롭 업로드¶

<div class="drag-drop-area" id="dropArea">
    <div class="drop-message">
        <i class="fa fa-cloud-upload"></i>
        <p>파일을 여기에 드래그하거나 클릭하여 업로드하세요</p>
        <input type="file" id="fileInput" multiple style="display: none;">
        <button type="button" class="btn-select-files">파일 선택</button>
    </div>

    <div class="progress-area" id="progressArea" style="display: none;">
        <div class="progress-bar">
            <div class="progress-fill" id="progressFill"></div>
        </div>
        <div class="progress-text" id="progressText">0%</div>
    </div>
</div>

<script>
class DragDropUpload {
    constructor(dropAreaId, fileInputId) {
        this.dropArea = document.getElementById(dropAreaId);
        this.fileInput = document.getElementById(fileInputId);
        this.progressArea = document.getElementById('progressArea');
        this.progressFill = document.getElementById('progressFill');
        this.progressText = document.getElementById('progressText');

        this.maxFileSize = 5 * 1024 * 1024; // 5MB
        this.allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'application/pdf'];

        this.initEvents();
    }

    initEvents() {
        // 드래그 앤 드롭 이벤트
        this.dropArea.addEventListener('dragover', this.handleDragOver.bind(this));
        this.dropArea.addEventListener('dragleave', this.handleDragLeave.bind(this));
        this.dropArea.addEventListener('drop', this.handleDrop.bind(this));

        // 클릭 업로드
        this.dropArea.addEventListener('click', () => {
            this.fileInput.click();
        });

        // 파일 선택 이벤트
        this.fileInput.addEventListener('change', (e) => {
            this.handleFiles(e.target.files);
        });
    }

    handleDragOver(e) {
        e.preventDefault();
        this.dropArea.classList.add('drag-over');
    }

    handleDragLeave(e) {
        e.preventDefault();
        this.dropArea.classList.remove('drag-over');
    }

    handleDrop(e) {
        e.preventDefault();
        this.dropArea.classList.remove('drag-over');

        const files = e.dataTransfer.files;
        this.handleFiles(files);
    }

    handleFiles(files) {
        for (let file of files) {
            if (this.validateFile(file)) {
                this.uploadFile(file);
            }
        }
    }

    validateFile(file) {
        // 파일 크기 검사
        if (file.size > this.maxFileSize) {
            alert(`파일 크기가 너무 큽니다. 최대 ${this.maxFileSize / 1024 / 1024}MB까지 업로드 가능합니다.`);
            return false;
        }

        // 파일 타입 검사
        if (!this.allowedTypes.includes(file.type)) {
            alert('허용되지 않는 파일 형식입니다.');
            return false;
        }

        return true;
    }

    async uploadFile(file) {
        const formData = new FormData();
        formData.append('file', file);
        formData.append('module', 'file');
        formData.append('act', 'procFileUpload');

        this.showProgress();

        try {
            const response = await fetch('/index.php', {
                method: 'POST',
                body: formData,
                onUploadProgress: (progressEvent) => {
                    const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
                    this.updateProgress(percentCompleted);
                }
            });

            const result = await response.json();

            if (result.error === '0') {
                this.onUploadSuccess(result);
            } else {
                this.onUploadError(result.message);
            }
        } catch (error) {
            this.onUploadError('업로드 중 오류가 발생했습니다.');
        }

        this.hideProgress();
    }

    showProgress() {
        this.progressArea.style.display = 'block';
    }

    hideProgress() {
        setTimeout(() => {
            this.progressArea.style.display = 'none';
            this.updateProgress(0);
        }, 1000);
    }

    updateProgress(percent) {
        this.progressFill.style.width = percent + '%';
        this.progressText.textContent = percent + '%';
    }

    onUploadSuccess(result) {
        // 업로드된 파일을 목록에 추가
        this.addFileToList(result.file_info);
        alert('파일이 성공적으로 업로드되었습니다.');
    }

    onUploadError(message) {
        alert('업로드 실패: ' + message);
    }

    addFileToList(fileInfo) {
        const fileList = document.getElementById('uploaded-files');
        const fileItem = document.createElement('div');
        fileItem.className = 'file-item';
        fileItem.innerHTML = `
            <div class="file-info">
                <span class="file-name">${fileInfo.source_filename}</span>
                <span class="file-size">${this.formatFileSize(fileInfo.file_size)}</span>
            </div>
            <div class="file-actions">
                <button type="button" class="btn-download" data-file-srl="${fileInfo.file_srl}">
                    <i class="fa fa-download"></i>
                </button>
                <button type="button" class="btn-delete" data-file-srl="${fileInfo.file_srl}">
                    <i class="fa fa-trash"></i>
                </button>
            </div>
        `;

        fileList.appendChild(fileItem);
    }

    formatFileSize(bytes) {
        if (bytes === 0) return '0 Bytes';

        const k = 1024;
        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
        const i = Math.floor(Math.log(bytes) / Math.log(k));

        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
    }
}

// 초기화
const dragDropUpload = new DragDropUpload('dropArea', 'fileInput');
</script>

CSS 스타일¶

.drag-drop-area {
    border: 2px dashed #ccc;
    border-radius: 8px;
    padding: 40px;
    text-align: center;
    cursor: pointer;
    transition: all 0.3s ease;
    margin: 20px 0;
}

.drag-drop-area:hover,
.drag-drop-area.drag-over {
    border-color: #007bff;
    background-color: #f8f9ff;
}

.drop-message {
    color: #666;
}

.drop-message i {
    font-size: 3em;
    color: #ccc;
    margin-bottom: 10px;
}

.drop-message p {
    margin: 10px 0;
    font-size: 16px;
}

.btn-select-files {
    background: #007bff;
    color: white;
    border: none;
    padding: 10px 20px;
    border-radius: 4px;
    cursor: pointer;
    margin-top: 10px;
}

.progress-area {
    margin-top: 20px;
}

.progress-bar {
    width: 100%;
    height: 20px;
    background: #f0f0f0;
    border-radius: 10px;
    overflow: hidden;
}

.progress-fill {
    height: 100%;
    background: #007bff;
    transition: width 0.3s ease;
}

.progress-text {
    margin-top: 10px;
    font-weight: bold;
    color: #007bff;
}

.uploaded-files {
    margin-top: 20px;
}

.file-item {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 10px;
    border: 1px solid #eee;
    border-radius: 4px;
    margin-bottom: 5px;
}

.file-info {
    flex: 1;
}

.file-name {
    font-weight: bold;
    margin-right: 10px;
}

.file-size {
    color: #666;
    font-size: 0.9em;
}

.file-actions {
    display: flex;
    gap: 5px;
}

.file-actions button {
    background: none;
    border: 1px solid #ddd;
    padding: 5px 8px;
    border-radius: 3px;
    cursor: pointer;
}

.btn-download:hover {
    background: #28a745;
    color: white;
    border-color: #28a745;
}

.btn-delete:hover {
    background: #dc3545;
    color: white;
    border-color: #dc3545;
}

이미지 처리¶

썸네일 생성¶

class ImageProcessor
{
    /**
     * 썸네일 생성
     */
    public static function createThumbnail($source_path, $dest_path, $width, $height, $quality = 85)
    {
        $image_info = getimagesize($source_path);
        if (!$image_info) {
            return false;
        }

        $original_width = $image_info[0];
        $original_height = $image_info[1];
        $image_type = $image_info[2];

        // 소스 이미지 로드
        switch ($image_type) {
            case IMAGETYPE_JPEG:
                $source_image = imagecreatefromjpeg($source_path);
                break;
            case IMAGETYPE_PNG:
                $source_image = imagecreatefrompng($source_path);
                break;
            case IMAGETYPE_GIF:
                $source_image = imagecreatefromgif($source_path);
                break;
            default:
                return false;
        }

        // 썸네일 크기 계산
        $thumb_size = self::calculateThumbnailSize($original_width, $original_height, $width, $height);

        // 썸네일 이미지 생성
        $thumb_image = imagecreatetruecolor($thumb_size['width'], $thumb_size['height']);

        // PNG 투명도 유지
        if ($image_type == IMAGETYPE_PNG) {
            imagealphablending($thumb_image, false);
            imagesavealpha($thumb_image, true);
            $transparent = imagecolorallocatealpha($thumb_image, 255, 255, 255, 127);
            imagefill($thumb_image, 0, 0, $transparent);
        }

        // 이미지 리샘플링
        imagecopyresampled(
            $thumb_image, $source_image,
            0, 0, 0, 0,
            $thumb_size['width'], $thumb_size['height'],
            $original_width, $original_height
        );

        // 썸네일 저장
        $result = false;
        switch ($image_type) {
            case IMAGETYPE_JPEG:
                $result = imagejpeg($thumb_image, $dest_path, $quality);
                break;
            case IMAGETYPE_PNG:
                $result = imagepng($thumb_image, $dest_path);
                break;
            case IMAGETYPE_GIF:
                $result = imagegif($thumb_image, $dest_path);
                break;
        }

        // 메모리 해제
        imagedestroy($source_image);
        imagedestroy($thumb_image);

        return $result;
    }

    /**
     * 썸네일 크기 계산
     */
    private static function calculateThumbnailSize($original_width, $original_height, $max_width, $max_height)
    {
        $ratio = min($max_width / $original_width, $max_height / $original_height);

        return array(
            'width' => round($original_width * $ratio),
            'height' => round($original_height * $ratio)
        );
    }

    /**
     * 워터마크 추가
     */
    public static function addWatermark($image_path, $watermark_path, $position = 'bottom-right')
    {
        $image = imagecreatefromjpeg($image_path);
        $watermark = imagecreatefrompng($watermark_path);

        $image_width = imagesx($image);
        $image_height = imagesy($image);
        $watermark_width = imagesx($watermark);
        $watermark_height = imagesy($watermark);

        // 워터마크 위치 계산
        switch ($position) {
            case 'top-left':
                $dest_x = 10;
                $dest_y = 10;
                break;
            case 'top-right':
                $dest_x = $image_width - $watermark_width - 10;
                $dest_y = 10;
                break;
            case 'bottom-left':
                $dest_x = 10;
                $dest_y = $image_height - $watermark_height - 10;
                break;
            case 'bottom-right':
            default:
                $dest_x = $image_width - $watermark_width - 10;
                $dest_y = $image_height - $watermark_height - 10;
                break;
            case 'center':
                $dest_x = ($image_width - $watermark_width) / 2;
                $dest_y = ($image_height - $watermark_height) / 2;
                break;
        }

        // 워터마크 합성
        imagecopy($image, $watermark, $dest_x, $dest_y, 0, 0, $watermark_width, $watermark_height);

        // 이미지 저장
        imagejpeg($image, $image_path, 85);

        // 메모리 해제
        imagedestroy($image);
        imagedestroy($watermark);

        return true;
    }
}

이미지 뷰어¶

<!-- 이미지 갤러리 -->
<div class="image-gallery">
    <!--@foreach($uploaded_files as $file)-->
    <!--@if($file->isImage())-->
    <div class="image-item">
        <img src="{$file->getThumbnail(200, 200)}" 
             alt="{$file->source_filename}"
             data-full-image="{$file->uploaded_filename}"
             class="gallery-thumbnail">

        <div class="image-overlay">
            <div class="image-actions">
                <button type="button" class="btn-view" data-image="{$file->uploaded_filename}">
                    <i class="fa fa-eye"></i>
                </button>
                <button type="button" class="btn-download" data-file-srl="{$file->file_srl}">
                    <i class="fa fa-download"></i>
                </button>
                <button type="button" class="btn-delete" data-file-srl="{$file->file_srl}">
                    <i class="fa fa-trash"></i>
                </button>
            </div>
        </div>
    </div>
    <!--@end-->
    <!--@end-->
</div>

<!-- 이미지 모달 -->
<div id="imageModal" class="image-modal" style="display: none;">
    <div class="modal-overlay" onclick="closeImageModal()"></div>
    <div class="modal-content">
        <img id="modalImage" src="" alt="">
        <button type="button" class="modal-close" onclick="closeImageModal()">
            <i class="fa fa-times"></i>
        </button>
        <div class="modal-navigation">
            <button type="button" class="btn-prev" onclick="navigateImage(-1)">
                <i class="fa fa-chevron-left"></i>
            </button>
            <button type="button" class="btn-next" onclick="navigateImage(1)">
                <i class="fa fa-chevron-right"></i>
            </button>
        </div>
    </div>
</div>

<script>
class ImageViewer {
    constructor() {
        this.images = [];
        this.currentIndex = 0;
        this.modal = document.getElementById('imageModal');
        this.modalImage = document.getElementById('modalImage');

        this.initEvents();
        this.loadImages();
    }

    initEvents() {
        // 썸네일 클릭 이벤트
        document.addEventListener('click', (e) => {
            if (e.target.classList.contains('gallery-thumbnail')) {
                const imageSrc = e.target.dataset.fullImage;
                this.openModal(imageSrc);
            }

            if (e.target.closest('.btn-view')) {
                const imageSrc = e.target.closest('.btn-view').dataset.image;
                this.openModal(imageSrc);
            }
        });

        // 키보드 내비게이션
        document.addEventListener('keydown', (e) => {
            if (this.modal.style.display === 'block') {
                switch (e.key) {
                    case 'Escape':
                        this.closeModal();
                        break;
                    case 'ArrowLeft':
                        this.navigateImage(-1);
                        break;
                    case 'ArrowRight':
                        this.navigateImage(1);
                        break;
                }
            }
        });
    }

    loadImages() {
        const thumbnails = document.querySelectorAll('.gallery-thumbnail');
        this.images = Array.from(thumbnails).map(thumb => thumb.dataset.fullImage);
    }

    openModal(imageSrc) {
        this.currentIndex = this.images.indexOf(imageSrc);
        this.modalImage.src = imageSrc;
        this.modal.style.display = 'block';
        document.body.style.overflow = 'hidden';
    }

    closeModal() {
        this.modal.style.display = 'none';
        document.body.style.overflow = '';
    }

    navigateImage(direction) {
        if (this.images.length === 0) return;

        this.currentIndex += direction;

        if (this.currentIndex >= this.images.length) {
            this.currentIndex = 0;
        } else if (this.currentIndex < 0) {
            this.currentIndex = this.images.length - 1;
        }

        this.modalImage.src = this.images[this.currentIndex];
    }
}

// 전역 함수들
function closeImageModal() {
    imageViewer.closeModal();
}

function navigateImage(direction) {
    imageViewer.navigateImage(direction);
}

// 초기화
const imageViewer = new ImageViewer();
</script>

파일 다운로드¶

안전한 파일 다운로드¶

class FileDownloader
{
    /**
     * 파일 다운로드 처리
     */
    public static function downloadFile($file_srl, $check_permission = true)
    {
        // 파일 정보 조회
        $oFileModel = getModel('file');
        $file_info = $oFileModel->getFile($file_srl);

        if (!$file_info || !$file_info->file_srl) {
            return new BaseObject(-1, '파일을 찾을 수 없습니다.');
        }

        // 권한 확인
        if ($check_permission) {
            $permission_result = self::checkDownloadPermission($file_info);
            if (!$permission_result->toBool()) {
                return $permission_result;
            }
        }

        $file_path = $file_info->uploaded_filename;

        // 파일 존재 확인
        if (!file_exists($file_path)) {
            return new BaseObject(-1, '파일이 존재하지 않습니다.');
        }

        // 다운로드 카운트 증가
        self::increaseDownloadCount($file_srl);

        // 파일 다운로드 헤더 설정
        self::setDownloadHeaders($file_info);

        // 파일 출력
        self::outputFile($file_path);

        exit;
    }

    /**
     * 다운로드 권한 확인
     */
    private static function checkDownloadPermission($file_info)
    {
        $logged_info = Context::get('logged_info');

        // 관리자는 모든 파일 다운로드 가능
        if ($logged_info && $logged_info->is_admin == 'Y') {
            return new BaseObject();
        }

        // 파일 소유자 확인
        if ($logged_info && $file_info->member_srl == $logged_info->member_srl) {
            return new BaseObject();
        }

        // 게시물 권한 확인
        if ($file_info->document_srl) {
            $oDocumentModel = getModel('document');
            $oDocument = $oDocumentModel->getDocument($file_info->document_srl);

            if ($oDocument && $oDocument->isAccessible()) {
                return new BaseObject();
            }
        }

        return new BaseObject(-1, '파일 다운로드 권한이 없습니다.');
    }

    /**
     * 다운로드 헤더 설정
     */
    private static function setDownloadHeaders($file_info)
    {
        $filename = $file_info->source_filename;
        $file_size = filesize($file_info->uploaded_filename);

        // 브라우저별 파일명 인코딩
        $user_agent = $_SERVER['HTTP_USER_AGENT'];
        if (strpos($user_agent, 'MSIE') !== false || strpos($user_agent, 'Trident') !== false) {
            $filename = rawurlencode($filename);
        } else {
            $filename = '=?UTF-8?B?' . base64_encode($filename) . '?=';
        }

        // 헤더 설정
        header('Content-Type: application/octet-stream');
        header('Content-Disposition: attachment; filename="' . $filename . '"');
        header('Content-Transfer-Encoding: binary');
        header('Content-Length: ' . $file_size);
        header('Cache-Control: private, no-transform, no-store, must-revalidate');
        header('Pragma: no-cache');
        header('Expires: 0');

        // 이미지 파일인 경우 미리보기 허용
        if ($file_info->isImage() && isset($_GET['preview'])) {
            header('Content-Type: ' . $file_info->mime_type);
            header('Content-Disposition: inline; filename="' . $filename . '"');
        }
    }

    /**
     * 파일 출력
     */
    private static function outputFile($file_path)
    {
        $chunk_size = 8192; // 8KB씩 읽기

        if ($file_handle = fopen($file_path, 'rb')) {
            while (!feof($file_handle)) {
                echo fread($file_handle, $chunk_size);
                flush();
            }
            fclose($file_handle);
        }
    }

    /**
     * 다운로드 횟수 증가
     */
    private static function increaseDownloadCount($file_srl)
    {
        $args = new stdClass();
        $args->file_srl = $file_srl;
        executeQuery('file.updateDownloadCount', $args);
    }
}

파일 관리 도구¶

파일 정리 스크립트¶

class FileManager
{
    /**
     * 고아 파일 정리
     */
    public static function cleanOrphanFiles()
    {
        // 데이터베이스에 없는 파일들 찾기
        $upload_dir = _XE_PATH_ . 'files/attach/';
        $files = FileHandler::readDir($upload_dir, '/\.(jpg|jpeg|png|gif|pdf|doc|docx|xls|xlsx|ppt|pptx|zip|hwp)$/i');

        $orphan_files = array();
        $total_size = 0;

        foreach ($files as $file) {
            $file_path = $upload_dir . $file;

            // 데이터베이스에서 파일 확인
            $args = new stdClass();
            $args->uploaded_filename = $file_path;
            $output = executeQuery('file.getFileByPath', $args);

            if (!$output->data) {
                $orphan_files[] = $file;
                $total_size += filesize($file_path);
            }
        }

        return array(
            'count' => count($orphan_files),
            'files' => $orphan_files,
            'total_size' => $total_size
        );
    }

    /**
     * 임시 파일 정리
     */
    public static function cleanTempFiles($older_than_days = 7)
    {
        $temp_dir = _XE_PATH_ . 'files/cache/tmp/';
        $cutoff_time = time() - ($older_than_days * 24 * 60 * 60);

        $temp_files = FileHandler::readDir($temp_dir);
        $cleaned_files = array();
        $total_size = 0;

        foreach ($temp_files as $file) {
            $file_path = $temp_dir . $file;

            if (filemtime($file_path) < $cutoff_time) {
                $file_size = filesize($file_path);
                if (unlink($file_path)) {
                    $cleaned_files[] = $file;
                    $total_size += $file_size;
                }
            }
        }

        return array(
            'count' => count($cleaned_files),
            'files' => $cleaned_files,
            'total_size' => $total_size
        );
    }

    /**
     * 중복 파일 찾기
     */
    public static function findDuplicateFiles()
    {
        $args = new stdClass();
        $output = executeQuery('file.getAllFiles', $args);

        if (!$output->toBool() || !$output->data) {
            return array();
        }

        $file_hashes = array();
        $duplicates = array();

        foreach ($output->data as $file_info) {
            if (!file_exists($file_info->uploaded_filename)) {
                continue;
            }

            $file_hash = md5_file($file_info->uploaded_filename);

            if (isset($file_hashes[$file_hash])) {
                if (!isset($duplicates[$file_hash])) {
                    $duplicates[$file_hash] = array($file_hashes[$file_hash]);
                }
                $duplicates[$file_hash][] = $file_info;
            } else {
                $file_hashes[$file_hash] = $file_info;
            }
        }

        return $duplicates;
    }

    /**
     * 스토리지 사용량 분석
     */
    public static function analyzeStorageUsage()
    {
        $stats = array(
            'total_files' => 0,
            'total_size' => 0,
            'by_extension' => array(),
            'by_month' => array(),
            'largest_files' => array()
        );

        $args = new stdClass();
        $output = executeQuery('file.getFileStatistics', $args);

        if ($output->toBool() && $output->data) {
            foreach ($output->data as $file_info) {
                $stats['total_files']++;
                $stats['total_size'] += $file_info->file_size;

                // 확장자별 통계
                $ext = strtolower(pathinfo($file_info->source_filename, PATHINFO_EXTENSION));
                if (!isset($stats['by_extension'][$ext])) {
                    $stats['by_extension'][$ext] = array('count' => 0, 'size' => 0);
                }
                $stats['by_extension'][$ext]['count']++;
                $stats['by_extension'][$ext]['size'] += $file_info->file_size;

                // 월별 통계
                $month = date('Y-m', strtotime($file_info->regdate));
                if (!isset($stats['by_month'][$month])) {
                    $stats['by_month'][$month] = array('count' => 0, 'size' => 0);
                }
                $stats['by_month'][$month]['count']++;
                $stats['by_month'][$month]['size'] += $file_info->file_size;

                // 큰 파일들
                $stats['largest_files'][] = array(
                    'filename' => $file_info->source_filename,
                    'size' => $file_info->file_size,
                    'regdate' => $file_info->regdate
                );
            }
        }

        // 큰 파일 정렬 (상위 10개)
        usort($stats['largest_files'], function($a, $b) {
            return $b['size'] - $a['size'];
        });
        $stats['largest_files'] = array_slice($stats['largest_files'], 0, 10);

        return $stats;
    }
}

파일 보안¶

업로드 파일 검증¶

class FileValidator
{
    private static $dangerous_extensions = array(
        'php', 'php3', 'php4', 'php5', 'phtml', 'asp', 'aspx', 'jsp', 'js', 'vbs', 'exe', 'com', 'bat', 'cmd', 'scr'
    );

    /**
     * 파일 안전성 검사
     */
    public static function validateFile($uploaded_file)
    {
        $errors = array();

        // 확장자 검사
        $extension_check = self::checkExtension($uploaded_file['name']);
        if (!$extension_check['valid']) {
            $errors[] = $extension_check['message'];
        }

        // MIME 타입 검사
        $mime_check = self::checkMimeType($uploaded_file['tmp_name'], $uploaded_file['type']);
        if (!$mime_check['valid']) {
            $errors[] = $mime_check['message'];
        }

        // 파일 내용 검사
        $content_check = self::checkFileContent($uploaded_file['tmp_name']);
        if (!$content_check['valid']) {
            $errors[] = $content_check['message'];
        }

        // 파일 크기 검사
        $size_check = self::checkFileSize($uploaded_file['size']);
        if (!$size_check['valid']) {
            $errors[] = $size_check['message'];
        }

        return array(
            'valid' => empty($errors),
            'errors' => $errors
        );
    }

    /**
     * 확장자 검사
     */
    private static function checkExtension($filename)
    {
        $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));

        // 위험한 확장자 차단
        if (in_array($extension, self::$dangerous_extensions)) {
            return array(
                'valid' => false,
                'message' => '업로드가 금지된 파일 형식입니다: ' . $extension
            );
        }

        // 허용된 확장자 목록 확인
        $allowed_extensions = Context::get('allowed_extensions');
        if ($allowed_extensions && !in_array($extension, $allowed_extensions)) {
            return array(
                'valid' => false,
                'message' => '허용되지 않는 파일 형식입니다: ' . $extension
            );
        }

        return array('valid' => true);
    }

    /**
     * MIME 타입 검사
     */
    private static function checkMimeType($tmp_name, $declared_type)
    {
        if (!function_exists('finfo_open')) {
            return array('valid' => true); // finfo 확장이 없으면 통과
        }

        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $actual_type = finfo_file($finfo, $tmp_name);
        finfo_close($finfo);

        // 허용된 MIME 타입 목록
        $allowed_types = array(
            'image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/bmp',
            'application/pdf', 'application/msword', 'application/vnd.ms-excel',
            'application/vnd.ms-powerpoint', 'text/plain', 'application/zip'
        );

        if (!in_array($actual_type, $allowed_types)) {
            return array(
                'valid' => false,
                'message' => '허용되지 않는 파일 타입입니다: ' . $actual_type
            );
        }

        return array('valid' => true);
    }

    /**
     * 파일 내용 검사
     */
    private static function checkFileContent($tmp_name)
    {
        $file_content = file_get_contents($tmp_name, false, null, 0, 1024); // 첫 1KB만 읽기

        // PHP 태그 검사
        if (strpos($file_content, '<?php') !== false || strpos($file_content, '<?=') !== false) {
            return array(
                'valid' => false,
                'message' => '실행 가능한 코드가 포함된 파일입니다.'
            );
        }

        // 스크립트 태그 검사
        if (stripos($file_content, '<script') !== false) {
            return array(
                'valid' => false,
                'message' => '스크립트가 포함된 파일입니다.'
            );
        }

        return array('valid' => true);
    }

    /**
     * 파일 크기 검사
     */
    private static function checkFileSize($file_size)
    {
        $max_size = Context::get('max_file_size') ?: (2 * 1024 * 1024); // 기본 2MB

        if ($file_size > $max_size) {
            return array(
                'valid' => false,
                'message' => '파일 크기가 너무 큽니다. 최대 ' . self::formatBytes($max_size) . '까지 업로드 가능합니다.'
            );
        }

        return array('valid' => true);
    }

    /**
     * 바이트를 읽기 쉬운 형태로 변환
     */
    private static function formatBytes($bytes, $precision = 2)
    {
        $units = array('B', 'KB', 'MB', 'GB', 'TB');

        for ($i = 0; $bytes > 1024; $i++) {
            $bytes /= 1024;
        }

        return round($bytes, $precision) . ' ' . $units[$i];
    }
}

모범 사례¶

보안: 업로드 파일에 대한 철저한 검증 수행
성능: 대용량 파일 처리 시 청크 단위로 처리
사용자 경험: 드래그 앤 드롭과 진행률 표시 제공
저장소 관리: 정기적인 파일 정리와 중복 제거
접근 제어: 파일별 권한 관리로 보안 강화

다음 단계¶

파일 관리를 마스터했다면, 위젯 사용법에서 디자인 커스터마이징을 학습하세요.