안녕, 미래의 시스템 마에스트로! 👋

어느 날 평화롭게 코딩을 하거나, 혹은 숨 막히는 게임의 마지막 보스를 앞두고 있는데...
화면이 갑자기 싸늘한 푸른색으로 변하며 정체불명의 흰 글씨를 토해내는 경험, 다들 한 번쯤은 있지 않아? 일명 '죽음의 블루스크린(BSOD)'이라고 불리는 공포의 순간 말이야. 심장이 쿵 하고 내려앉고, 머릿속은 하얘지고, "내 과제... 내 프로젝트... 내 게임 저장 파일...!"을 외치게 되는 바로 그 순간. 😱

이런 디지털 대참사 앞에서 우리는 속수무책으로 좌절하곤 해. 하지만 만약, 이 모든 걸 되돌릴 수 있는 '시간 여행 장치'가 있다면 어떨까? 마치 영화 속 주인공처럼 시간을 되돌려 컴퓨터가 멀쩡했던 그 순간으로 돌아가는 거지. 오늘 우리가 이야기할 '시스템 복구 도구'가 바로 그런 역할을 하는 디지털 세계의 응급구조사, 혹은 타임머신이야.

그리고 더 흥미로운 건, 이 강력한 도구를 우리 손으로 직접, 그것도 컴퓨터의 심장과 가장 가까운 언어인 C언어로 만들어 볼 거라는 사실이지. "왜 하필 C언어냐고?" 좋은 질문이야. C언어는 화려한 최신 언어들처럼 모든 걸 알아서 챙겨주는 친절함은 좀 부족할지 몰라. 하지만 운영체제의 가장 깊숙한 곳까지 손을 뻗어 하드웨어를 직접 주무를 수 있는 막강한 파워와 스피드를 가졌어. 시스템 복구 도구처럼 컴퓨터의 생사를 다루는 작업에는 이만한 '해결사'가 없다는 거지.

이 글은 단순한 코딩 강의가 아니야. 나와 함께 시스템의 내부를 탐험하고, 파일과 데이터가 어떻게 살아 숨 쉬는지 이해하며, 마침내 내 PC를 지킬 수 있는 든든한 방패를 만들어가는 대장정이 될 거야. 준비됐어? 그럼 지금부터 키보드를 꽉 잡고, C언어와 함께하는 시스템 복구의 세계로 다이브해보자! 💻✨

PART 1: 설계도 그리기 - 시스템 복구 도구, 대체 넌 누구냐?

우리가 만들려는 '시스템 복구 도구'가 정확히 어떤 녀석인지부터 확실히 알고 가야겠지? 그냥 '컴퓨터 고쳐주는 프로그램'이라고 뭉뚱그리기엔 그 안에 너무나도 중요한 기능들이 숨어있어. 마치 어벤져스 팀처럼 각기 다른 능력을 가진 영웅들이 모여 하나의 강력한 팀을 이루는 것과 같아.

핵심 기능 4대 천왕 👑

모든 시스템 복구 도구는 크게 네 가지 핵심 기능을 중심으로 만들어져. 이 네 가지를 이해하면 우리가 앞으로 무엇을 만들어야 할지 명확한 그림이 그려질 거야.

1. 백업 (Backup): 디지털 금고 만들기
가장 기본이자 가장 중요한 기능이야. '백업'은 현재 시스템의 건강한 상태를 사진 찍듯이 '스냅샷'으로 저장해두는 작업이야. 이 스냅샷에는 중요한 파일, 설정, 심지어 운영체제 전체가 포함될 수 있어. 문제가 생겼을 때 돌아갈 수 있는 '세이브 포인트'를 만드는 거지.
- 파일 기반 백업: 사용자가 지정한 특정 폴더나 파일들만 쏙쏙 골라서 복사해두는 방식. '내 문서' 폴더나 프로젝트 폴더처럼 중요한 데이터만 챙기고 싶을 때 유용해.
- 이미지 기반 백업: 하드디스크나 SSD를 통째로, 섹터 하나하나까지 완벽하게 복제해서 하나의 거대한 파일(이미지 파일)로 만드는 방식이야. 운영체제, 설치된 프로그램, 모든 데이터를 한 방에 저장하는 가장 확실한 방법이지.

2. 복원 (Restore): 시간을 되돌리는 마법
백업의 단짝 친구. 미리 만들어 둔 '디지털 금고(백업 파일)'를 열어서 시스템을 과거의 건강했던 상태로 되돌리는 기능이야. 바이러스에 감염되었거나, 프로그램을 잘못 설치해서 시스템이 엉망이 되었을 때 이 기능 하나면 모든 걸 없었던 일로 만들 수 있어. 그야말로 디지털 타임머신이지! ⏳

3. 복구 및 수리 (Repair): 아픈 곳을 치료하는 의사
시스템이 부팅조차 되지 않는 심각한 상황에 필요한 기능이야. 단순히 과거로 돌아가는 것을 넘어, 문제의 원인을 직접 진단하고 치료하는 역할을 해.
- 부트 로더(Bootloader) 복구: 컴퓨터 전원을 켰을 때 운영체제를 깨우는 역할을 하는 '부트 로더'가 손상되면 컴퓨터는 아예 켜지지도 않아. 이 부트 로더를 고쳐서 다시 시동을 걸 수 있게 해줘.
- 파일 시스템 오류 검사/수정: 디스크에 파일이 저장되는 규칙(파일 시스템)이 깨졌을 때, 조각난 정보를 맞추고 오류를 수정해서 파일을 살려내는 작업이야. Windows의 `chkdsk` 명령어가 바로 이런 역할을 하지.

4. 진단 (Diagnostics): 건강검진
문제가 생기기 전에 미리 시스템의 건강 상태를 체크하는 기능이야. 하드디스크에 불량 섹터는 없는지, 메모리(RAM)는 제대로 작동하는지 등을 검사해서 잠재적인 위험을 미리 알려주는 고마운 기능이지.

왜 굳이 C언어로 이 힘든 길을? 🤔

요즘 파이썬이나 자바스크립트 같은 쉽고 편한 언어도 많은데, 왜 하필 C언어냐고? 그건 바로 C언어가 가진 독보적인 특징 때문이야.

1. 속도, 그 자체:
C언어는 컴파일 언어의 제왕이야. 실행 파일을 한 번 만들어두면, 인터프리터 언어처럼 한 줄 한 줄 번역할 필요 없이 기계가 바로 알아듣는 언어로 미친 듯이 달려가지. 수십, 수백 기가바이트의 데이터를 다루는 백업/복원 작업에서 이 속도는 생명과도 같아.

2. 하드웨어와의 뜨거운 만남:
C언어는 '시스템 프로그래밍 언어'라는 별명답게, 운영체제의 가장 깊은 곳, 하드웨어와 직접적으로 소통할 수 있어. 메모리 주소를 직접 제어하는 포인터, 운영체제가 제공하는 저수준 API(Application Programming Interface) 호출 등을 통해 파일 시스템, 디스크 드라이브, 메모리 등을 마음껏 주무를 수 있지. 이건 다른 고수준 언어들이 쉽게 흉내 낼 수 없는 C언어만의 특권이야.

3. 이식성 (Portability):
표준 C 라이브러리를 사용해서 코드를 잘 작성하면, Windows, Linux, macOS 등 다양한 운영체제에서 거의 수정 없이 컴파일해서 사용할 수 있어. 물론 운영체제별로 다른 API를 쓰는 부분은 따로 처리해줘야 하지만, 핵심 로직은 그대로 가져갈 수 있다는 건 엄청난 장점이지.

결론적으로, 시스템 복구 도구처럼 성능과 제어 능력이 극한으로 요구되는 분야에서 C언어는 여전히 대체 불가능한 '왕의 언어'라고 할 수 있어. 조금 어렵고 까다로워도, 이 과정을 통해 우리는 컴퓨터의 동작 원리를 훨씬 더 깊게 이해하게 될 거야. 이게 바로 찐개발자로 성장하는 길이지! 😉

PART 2: 개발 장비 풀세팅 - 우리의 작업실을 꾸며보자 🛠️

자, 이제 설계도도 나왔으니 본격적으로 연장을 챙겨볼 시간이야. C언어로 시스템 복구 도구를 만들기 위해 필요한 최소한의, 하지만 가장 강력한 개발 환경을 세팅해 보자. 거창한 장비는 필요 없어. 지금 네가 사용하는 컴퓨터만 있으면 충분해!

필수 장비 리스트 (feat. 전부 무료!)

1. 컴파일러 (Compiler): C언어 번역가
우리가 작성한 C언어 코드(사람이 읽는 언어)를 컴퓨터가 이해할 수 있는 기계어(0과 1의 세상)로 번역해 주는 프로그램이야. 이게 없으면 C언어는 그냥 텍스트 파일에 불과해.
- Windows 사용자라면: MinGW-w64를 강력 추천해. 'Minimalist GNU for Windows'의 약자로, Windows 환경에서 GCC(GNU Compiler Collection)를 사용할 수 있게 해주는 도구 모음이야. 이걸 설치하면 Windows에서도 리눅스 개발자처럼 터미널에서 `gcc` 명령어로 컴파일하는 갬성을 느낄 수 있어.
- macOS 또는 Linux 사용자라면: 축하해! 넌 이미 최고의 컴파일러를 가지고 있을 확률이 높아. 터미널을 열고 `gcc --version` 또는 `clang --version`을 입력해 봐. 대부분 기본적으로 설치되어 있을 거야.

2. 코드 에디터 (Code Editor): 우리의 놀이터
C 코드를 작성하고 편집할 공간이야. 메모장으로도 할 수는 있지만, 코딩에 특화된 에디터를 쓰면 생산성이 수직 상승해.
- Visual Studio Code (VS Code): 현재 전 세계 개발자들의 사랑을 한 몸에 받고 있는, 말이 필요 없는 최고의 선택. 가볍고 빠르면서도, C/C++ 확장 프로그램을 설치하면 거의 완벽한 C언어 개발 환경이 구축돼. 코드 자동 완성, 디버깅, 터미널 통합까지... 그냥 이걸 쓰면 돼. 👍

3. 터미널 (Terminal) 또는 명령 프롬프트 (Command Prompt): 우리의 지휘 본부
컴파일러에게 "이 코드 번역해 줘!"라고 명령을 내리고, 완성된 프로그램을 실행시키는 곳이야. GUI 환경에 익숙한 친구들은 어색할 수 있지만, 진짜 개발자는 키보드로 모든 걸 지휘하는 법이지. VS Code 안에 내장된 터미널을 사용하면 되니까 따로 설치할 필요는 없어.

Hello, System! - 첫 삽 뜨기

모든 장비가 준비됐다면, 이제 진짜 코드로 시스템과 첫인사를 나눌 시간이야. 'Hello, World!'는 너무 식상하니까, 우리는 시스템 복구 도구의 첫걸음답게 현재 작업 중인 폴더에 어떤 파일들이 있는지 목록을 보여주는 프로그램을 만들어 볼 거야.

이 예제는 Windows 환경을 기준으로 작성되었어. Windows 시스템의 기능을 사용하기 위해 `windows.h`라는 헤더 파일을 포함할 거야. 이게 바로 C언어로 운영체제와 소통하는 방법의 시작이야.

#include <stdio.h>
#include <windows.h>

int main() {
    // WIN32_FIND_DATA 구조체는 파일 정보를 담는 그릇 역할을 해.
    WIN32_FIND_DATA findFileData;

    // FindFirstFile 함수는 특정 경로에서 첫 번째 파일을 찾는 Windows API 함수야.
    // "*.*"는 '모든 파일을 찾아라'라는 의미의 와일드카드.
    HANDLE hFind = FindFirstFile("*.*", &findFileData);

    // 파일을 찾지 못했다면 INVALID_HANDLE_VALUE를 반환해.
    if (hFind == INVALID_HANDLE_VALUE) {
        printf("Error: Failed to find files.\n");
        return 1; // 프로그램 비정상 종료
    }

    printf("===== Files in current directory =====\n");

    // do-while 루프를 사용해서 첫 번째 찾은 파일부터 처리하고,
    // 그 다음 파일들을 순서대로 찾아 나갈 거야.
    do {
        // findFileData.dwFileAttributes는 파일의 속성(폴더인지, 숨김 파일인지 등)을 담고 있어.
        // FILE_ATTRIBUTE_DIRECTORY 플래그를 확인해서 폴더인지 파일인지 구분할 수 있지.
        if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            printf("[D] %s\n", findFileData.cFileName); // [D]는 Directory(폴더)라는 뜻
        } else {
            // LARGE_INTEGER 타입은 64비트 정수를 다루기 위한 구조체야.
            // 요즘 파일 크기는 32비트(약 4GB)를 훌쩍 넘기 때문에 이걸 사용해야 안전해.
            LARGE_INTEGER fileSize;
            fileSize.LowPart = findFileData.nFileSizeLow;
            fileSize.HighPart = findFileData.nFileSizeHigh;
            printf("[F] %s (%lld bytes)\n", findFileData.cFileName, fileSize.QuadPart); // [F]는 File
        }
    } while (FindNextFile(hFind, &findFileData) != 0); // 다음 파일이 있으면 계속 반복!

    // 파일 검색이 끝났으면 반드시 핸들을 닫아줘야 시스템 자원이 낭비되지 않아.
    FindClose(hFind);

    printf("====================================\n");

    return 0; // 프로그램 정상 종료
}

자, 이 코드를 `list_files.c`라는 이름으로 저장하고, VS Code 터미널에서 아래 명령어를 입력해 봐.

gcc list_files.c -o list_files.exe

이 명령어는 "GCC 컴파일러야, `list_files.c` 파일을 번역해서 `list_files.exe`라는 실행 파일을 만들어줘!"라는 뜻이야. 에러 없이 컴파일이 성공했다면, 이제 터미널에 이렇게 입력해 보자.

./list_files.exe

어때? 현재 폴더에 있는 파일과 폴더 목록이 멋지게 출력되지? 🎉
우리는 방금 C언어와 Windows API를 사용해서 파일 시스템의 정보를 직접 읽어오는 데 성공한 거야. 이건 단순한 시작이 아니야. 파일을 읽고, 쓰고, 복사하는 모든 작업의 기초를 다진 셈이지. 이제 이 기술을 확장해서 진짜 백업 기능을 만들어 볼 거야. 가슴이 웅장해지지 않아? 😉

PART 3: 핵심 임무 돌입 - C언어로 빚는 백업 로직 💾

드디어 우리 프로젝트의 심장부를 만들 시간이야. 시스템을 안전하게 지켜줄 '백업' 기능을 C언어로 한 땀 한 땀 구현해 볼 거야. 우리는 여기서 '파일 기반 백업'에 집중할 거야. 특정 폴더를 통째로 다른 곳에 복사해서 백업을 만드는 거지. 이 과정은 생각보다 훨씬 더 깊이가 있어. 단순 복사/붙여넣기가 아니라, 폴더 구조를 그대로 유지하면서 모든 파일을 빠짐없이 옮기는 정교한 작업이 필요하거든.

이 작업을 위해 우리는 '재귀 함수(Recursive Function)'라는 아주 강력한 프로그래밍 기술을 사용할 거야. 재귀 함수는 함수가 자기 자신을 다시 호출하는 구조인데, 폴더 안에 또 다른 폴더가 있고, 그 안에 또 폴더가 있는 복잡한 디렉터리 구조를 탐색하는 데 이보다 더 우아하고 효과적인 방법은 없어.

백업 로직 설계: 작전 계획 브리핑

우리의 백업 함수 `backupDirectory`는 대략 이런 순서로 작동할 거야.

1. 입력 받기: 백업할 원본 폴더 경로(`source`)와 백업 파일을 저장할 대상 폴더 경로(`destination`)를 입력받는다. 2. 대상 폴더 확인 및 생성: 대상 폴더가 존재하는지 확인하고, 없다면 새로 만들어준다. 이건 백업 파일들을 담을 집을 먼저 짓는 것과 같아. 3. 원본 폴더 탐색 시작: 원본 폴더 안에 있는 파일과 하위 폴더들을 하나씩 훑기 시작한다. 4. 파일인가, 폴더인가?: * 만약 파일을 발견하면, 대상 폴더에 그대로 복사한다. (파일 복사 로직) * 만약 하위 폴더를 발견하면? 바로 여기서 '재귀 호출'이 일어난다! 자기 자신(`backupDirectory` 함수)을 다시 부르면서, 이번에는 방금 발견한 하위 폴더를 새로운 원본 폴더로, 그리고 대상 폴더 안에도 똑같은 이름의 하위 폴더를 만들어서 새로운 대상 폴더로 지정해준다. 5. 탐색 완료까지 반복: 원본 폴더 내의 모든 항목을 다 처리할 때까지 3~4번 과정을 반복한다.

이 과정을 통해 아무리 깊고 복잡한 폴더 구조라도 원본과 똑같은 모습으로 대상 폴더에 복제되는 거야. 신기하지? 😉

실전 코드: `backupDirectory` 함수 구현하기

이제 실제 코드를 보면서 이 작전이 어떻게 구현되는지 자세히 살펴보자. 코드가 이전보다 길고 복잡해 보일 수 있지만, 주석을 꼼꼼히 읽으면서 따라오면 충분히 이해할 수 있을 거야. 천천히 가보자고.

#include <stdio.h>
#include <string.h>
#include <windows.h>

// 파일 하나를 복사하는 함수
void copyFile(const char *sourceFile, const char *destFile) {
    // CopyFile이라는 편리한 Windows API 함수가 있어.
    // 세 번째 인자는 '만약 같은 이름의 파일이 있으면 덮어쓸 것인가?'인데, FALSE는 덮어쓰지 않겠다는 의미.
    // 여기서는 TRUE로 해서 백업할 때마다 최신 파일로 덮어쓰도록 하자.
    if (CopyFile(sourceFile, destFile, FALSE)) {
        printf("Copied: %s -> %s\n", sourceFile, destFile);
    } else {
        printf("Error copying file: %s (Error code: %lu)\n", sourceFile, GetLastError());
    }
}

// 디렉터리를 백업하는 핵심 재귀 함수
void backupDirectory(const char *sourceDir, const char *destDir) {
    WIN32_FIND_DATA findFileData;
    char sourcePath[MAX_PATH];
    char destPath[MAX_PATH];

    // 대상 디렉터리가 없으면 생성
    // CreateDirectory 함수는 디렉터리 생성에 성공하면 0이 아닌 값을 반환해.
    if (!CreateDirectory(destDir, NULL)) {
        // 이미 디렉터리가 존재하는 경우(ERROR_ALREADY_EXISTS)는 정상이므로 에러 처리에서 제외.
        if (GetLastError() != ERROR_ALREADY_EXISTS) {
            printf("Error creating destination directory: %s\n", destDir);
            return;
        }
    }

    // 원본 디렉터리의 모든 파일과 폴더를 찾기 위해 경로 패턴을 만듦. 예: C:\source\*
    sprintf(sourcePath, "%s\\*", sourceDir);

    HANDLE hFind = FindFirstFile(sourcePath, &findFileData);
    if (hFind == INVALID_HANDLE_VALUE) {
        printf("Error: Could not find files in %s\n", sourceDir);
        return;
    }

    printf("\n--- Start Backup for [%s] ---\n", sourceDir);

    do {
        // "." (현재 디렉터리)와 ".." (상위 디렉터리)는 무한 루프를 유발할 수 있으므로 건너뛰어야 해.
        if (strcmp(findFileData.cFileName, ".") == 0 || strcmp(findFileData.cFileName, "..") == 0) {
            continue;
        }

        // 전체 경로를 만들기 위해 현재 경로와 파일/폴더 이름을 합쳐줌.
        sprintf(sourcePath, "%s\\%s", sourceDir, findFileData.cFileName);
        sprintf(destPath, "%s\\%s", destDir, findFileData.cFileName);

        // 폴더인 경우
        if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            printf("Found directory: %s\n", sourcePath);
            // 재귀 호출! 하위 폴더를 백업하기 위해 자기 자신을 다시 부른다.
            backupDirectory(sourcePath, destPath);
        }
        // 파일인 경우
        else {
            printf("Found file: %s\n", sourcePath);
            // 파일 복사 함수 호출
            copyFile(sourcePath, destPath);
        }

    } while (FindNextFile(hFind, &findFileData) != 0);

    FindClose(hFind);
    printf("--- Backup Complete for [%s] ---\n", sourceDir);
}

int main() {
    // 백업할 원본 폴더 경로. 실제 존재하는 폴더 경로로 바꿔서 테스트해봐!
    // 백슬래시(\)는 C언어에서 특별한 의미(이스케이프 문자)를 가지므로 두 번 써서 (\\) 표현해야 해.
    char source[] = "C:\\Users\\YourUser\\Documents\\ProjectA";

    // 백업 파일이 저장될 대상 폴더 경로.
    char destination[] = "D:\\Backup\\ProjectA_backup";

    printf("Starting backup process...\n");
    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    backupDirectory(source, destination);

    printf("\nAll backup tasks are complete! 🎉\n");

    return 0;
}

이 코드를 컴파일하고 실행하면, `source` 폴더의 모든 내용이 `destination` 폴더로 완벽하게 복제되는 것을 볼 수 있어. 터미널에 출력되는 로그를 보면 프로그램이 어떻게 폴더를 탐색하고 파일을 복사하는지 그 과정을 생생하게 지켜볼 수 있지. 이것만으로도 이미 훌륭한 개인용 백업 유틸리티가 탄생한 거야! 🥳

PART 4: 구출 작전 개시 - 믿음직한 복원 로직 구현하기 ↩️

자, 우리는 이제 어떤 폴더든 안전하게 백업할 수 있는 '디지털 금고'를 만드는 능력을 갖게 됐어. 하지만 금고에 보물을 넣어두기만 하고 꺼낼 수 없다면 아무 소용이 없겠지? 이제는 그 금고를 열어 소중한 데이터를 다시 꺼내오는 '복원' 기능을 만들 차례야. 구출 작전을 시작하자!

복원 로직은 사실 백업 로직과 거의 똑같아. 동전의 양면과도 같지. 백업이 '원본 → 백업본'으로 데이터를 옮기는 과정이었다면, 복원은 '백업본 → 원본 위치'로 데이터를 옮기는 과정일 뿐이야. 우리가 PART 3에서 만들었던 `backupDirectory` 함수를 거의 그대로 활용할 수 있어.

복원 로직: 백업의 데칼코마니

함수 이름만 `restoreDirectory`로 바꾸고, `sourceDir`와 `destDir`의 역할만 바꿔주면 돼. 즉, `main` 함수에서 `restoreDirectory`를 호출할 때, 백업 폴더 경로를 첫 번째 인자로, 원래 데이터가 있던 폴더 경로를 두 번째 인자로 넘겨주면 되는 거지.

백업 코드를 그대로 복사해서 `restore_logic.c` 파일을 만들고, 함수 이름과 `main` 함수 호출 부분만 살짝 수정해 보자.

#include <stdio.h>
#include <string.h>
#include <windows.h>

// 파일 복사 함수는 백업 때와 동일하게 사용 가능
void copyFile(const char *sourceFile, const char *destFile) {
    // 복원 시에는 기존 파일을 덮어쓰는 것이 일반적이므로 세 번째 인자를 TRUE로 설정.
    if (CopyFile(sourceFile, destFile, FALSE)) { // FALSE는 덮어쓰지 않음. 만약 덮어쓰려면 TRUE
        printf("Restored: %s -> %s\n", sourceFile, destFile);
    } else {
        // 만약 파일이 이미 존재해서 덮어쓰기 실패(FALSE 설정 시)하는 경우를 대비한 로그
        if (GetLastError() == ERROR_FILE_EXISTS) {
             printf("Skipped (already exists): %s\n", destFile);
        } else {
             printf("Error restoring file: %s (Error code: %lu)\n", sourceFile, GetLastError());
        }
    }
}

// 디렉터리를 복원하는 핵심 재귀 함수 (backupDirectory와 구조가 동일)
void restoreDirectory(const char *backupSourceDir, const char *originalDestDir) {
    WIN32_FIND_DATA findFileData;
    char sourcePath[MAX_PATH];
    char destPath[MAX_PATH];

    // 복원될 위치에 디렉터리가 없으면 생성
    if (!CreateDirectory(originalDestDir, NULL)) {
        if (GetLastError() != ERROR_ALREADY_EXISTS) {
            printf("Error creating destination directory: %s\n", originalDestDir);
            return;
        }
    }

    // 백업 소스 디렉터리의 모든 파일과 폴더를 찾기
    sprintf(sourcePath, "%s\\*", backupSourceDir);

    HANDLE hFind = FindFirstFile(sourcePath, &findFileData);
    if (hFind == INVALID_HANDLE_VALUE) {
        return; // 백업 소스가 비어있을 수 있으므로 조용히 종료
    }

    printf("\n--- Start Restore for [%s] ---\n", originalDestDir);

    do {
        if (strcmp(findFileData.cFileName, ".") == 0 || strcmp(findFileData.cFileName, "..") == 0) {
            continue;
        }

        sprintf(sourcePath, "%s\\%s", backupSourceDir, findFileData.cFileName);
        sprintf(destPath, "%s\\%s", originalDestDir, findFileData.cFileName);

        if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            // 재귀 호출로 하위 폴더 복원
            restoreDirectory(sourcePath, destPath);
        } else {
            // 파일 복원
            copyFile(sourcePath, destPath);
        }

    } while (FindNextFile(hFind, &findFileData) != 0);

    FindClose(hFind);
    printf("--- Restore Complete for [%s] ---\n", originalDestDir);
}

int main() {
    // 백업 데이터가 저장된 폴더 경로
    char backupLocation[] = "D:\\Backup\\ProjectA_backup";

    // 데이터를 복원할 원래 위치
    char originalLocation[] = "C:\\Users\\YourUser\\Documents\\ProjectA_Restored";

    printf("Starting restore process...\n");
    printf("Source (Backup): %s\n", backupLocation);
    printf("Destination (Original): %s\n", originalLocation);

    restoreDirectory(backupLocation, originalLocation);

    printf("\nAll restore tasks are complete! Your data is back. ✨\n");

    return 0;
}

복원, 그 이상의 고민: 안전장치는 필수! 🛡️

코드는 간단하게 완성됐지만, 실제 '복원' 작업은 백업보다 훨씬 더 신중해야 해. 백업은 최악의 경우 실패해도 원본 데이터는 그대로 남아있지만, 복원은 기존 데이터를 덮어쓰는 행위이기 때문에 한 번의 실수가 돌이킬 수 없는 데이터 손실로 이어질 수 있어.

그래서 상용 복구 프로그램들은 여러 겹의 안전장치를 마련해 둬. 우리도 몇 가지 아이디어를 생각해보자.

1. 사용자 확인 절차:
복원을 시작하기 전에 "정말로 `{대상 폴더}`의 내용을 `{백업 폴더}`의 내용으로 덮어쓰시겠습니까? 이 작업은 되돌릴 수 없습니다. (Y/N)" 와 같은 강력한 경고 메시지와 함께 사용자 확인을 받는 과정은 필수야.

2. 복원 전 미리 백업:
'복원'을 실행하기 전에, 현재 덮어쓰려는 대상 폴더의 상태를 다른 임시 폴더에 한 번 더 백업해두는 거야. 만약 복원 과정에서 뭔가 잘못되거나, 복원한 결과가 마음에 들지 않을 때 방금 전 상태로 되돌아갈 수 있는 '보험'을 들어두는 셈이지.

3. 버전 관리:
백업할 때마다 `ProjectA_backup_20231027_1530` 처럼 날짜와 시간 정보를 포함한 폴더를 만들어서 여러 개의 백업 버전을 보관하는 거야. 이렇게 하면 "아, 어제 백업한 걸로 복원했어야 했는데!" 같은 실수를 막고 원하는 시점의 데이터로 정확하게 돌아갈 수 있어.

이런 안전장치들을 C언어로 구현하는 건 지금까지 우리가 배운 파일/디렉터리 처리 기술을 응용하면 충분히 가능해. 예를 들어, 사용자 입력을 받기 위해서는 `scanf`나 `fgets` 함수를, 현재 시간을 얻기 위해서는 `time.h` 헤더의 함수들을 사용할 수 있지. 이런 디테일이 프로그램을 단순한 '기능'에서 신뢰할 수 있는 '도구'로 만들어주는 핵심이야.

PART 5: 시스템 의무병 - 고급 복구 기능 엿보기 🩺

지금까지 우리는 파일과 폴더를 다루는, 비교적 안전하고 이해하기 쉬운 영역에 머물러 있었어. 하지만 진짜 '시스템 복구'의 영역으로 한 걸음 더 들어가면, 운영체제의 심장부와 마주하게 돼. 이 부분은 매우 위험하고 복잡해서 직접 코드를 짜보는 대신, 어떤 원리로 동작하는지 개념을 이해하고 '아, C언어의 힘이 여기까지 닿는구나'를 느껴보는 데 초점을 맞출 거야. 마치 의대생이 해부학 책으로 인체의 신비를 공부하는 것처럼 말이지.

부팅의 비밀: MBR과 부트 로더

컴퓨터 전원 버튼을 누르면 어떻게 바탕화면이 뜰까? 그 과정의 첫 단추를 꿰는 역할이 바로 부트 로더(Bootloader)야. 그리고 이 부트 로더를 어디서 찾아야 할지 알려주는 지도 같은 것이 디스크의 가장 첫 부분에 기록된 MBR(Master Boot Record) 또는 최신 시스템의 GPT(GUID Partition Table)에 들어있어.

만약 MBR이나 부트 로더가 손상되면, 컴퓨터는 운영체제를 어디서부터 읽어야 할지 몰라 "Operating System not found" 같은 삭막한 메시지만 띄우고 멈춰버려. 😱

C언어는 이런 저수준 영역에도 접근할 수 있어. 예를 들어 Windows에서는 `CreateFile` API에 `\\.\PhysicalDrive0` 같은 특별한 경로를 주면, 하드디스크 전체를 하나의 거대한 파일처럼 열 수 있어. 그리고 `ReadFile` 함수로 디스크의 첫 512바이트를 읽으면, 그게 바로 MBR이야. 그 내용을 분석하고, 정상적인 MBR 코드로 덮어써서 부팅 문제를 해결하는 것이 부트 로더 복구 툴의 원리지.

파일 시스템 자가 치유: `chkdsk`의 원리

파일을 저장하고 삭제하다 보면 가끔 파일 시스템의 연결고리가 꼬일 때가 있어. 파일의 실제 데이터는 디스크에 있는데, 목차(FAT, MFT 등)에는 기록이 사라지거나, 반대로 목차에는 있는데 데이터가 사라지는 등. 이런 상태를 '파일 시스템 오류'라고 해.

Windows의 `chkdsk`나 리눅스의 `fsck` 같은 도구는 파일 시스템의 규칙(예: NTFS의 구조)을 완벽하게 이해하고 있어. 그래서 디스크 전체를 스캔하면서 이 규칙에 맞지 않는 '논리적 오류'들을 찾아내. 예를 들어, A라는 파일이 디스크의 100번, 101번, 105번 조각을 사용한다고 기록되어 있는데, B라는 파일도 105번 조각을 사용한다고 되어 있다면? 이건 명백한 오류지. `chkdsk`는 이런 '교차 연결된 파일'을 찾아내서 연결을 끊거나 복사본을 만들어주는 식으로 문제를 해결해.

이런 도구를 C언어로 만든다는 건, NTFS나 FAT32 같은 파일 시스템의 명세서를 통째로 외우고, 그 구조를 파싱해서 오류를 찾아내는 코드를 짜야 한다는 의미야. 이건 거의 운영체제를 하나 만드는 것과 맞먹는 수준의 방대한 작업이지. 하지만 불가능한 건 아니야. 수많은 오픈소스 디스크 복구 툴들이 바로 이런 원리로 만들어졌으니까.

Windows의 아킬레스건: 레지스트리 복구

Windows 사용자들이라면 '레지스트리'라는 말을 들어봤을 거야. 이건 Windows 운영체제와 설치된 모든 프로그램의 설정 정보를 담고 있는 거대한 데이터베이스야. 창 크기, 바탕화면 배경, 프로그램 설치 경로 등 모든 것이 여기에 기록돼. 그래서 레지스트리가 꼬이면 특정 프로그램이 실행되지 않거나, 시스템 전체가 불안정해지는 문제가 발생해.

C언어는 Windows API를 통해 이 레지스트리에 직접 접근할 수 있어. - `RegOpenKeyEx`: 특정 레지스트리 키(폴더 같은 개념)를 연다. - `RegQueryValueEx`: 키 안의 값(설정 데이터)을 읽는다. - `RegSetValueEx`: 키 안의 값을 쓴다. - `RegCreateKeyEx`: 새로운 키를 만든다.

시스템 복구 도구는 이 함수들을 이용해서 중요한 레지스트리 키들을 파일로 백업(`RegSaveKey` API)해뒀다가, 문제가 생겼을 때 다시 원래대로 복원(`RegRestoreKey` API)하는 기능을 제공할 수 있어. 악성코드가 시스템 설정을 멋대로 바꿨을 때, 이 기능으로 한 방에 정상으로 되돌릴 수 있는 거지.

이처럼 시스템의 깊은 곳을 다루는 기능들은 C언어의 진정한 힘을 보여주는 영역이야. 우리가 만든 파일 백업/복원 도구에 이런 고급 기능들이 하나씩 추가된다면, 시중에서 판매되는 상용 프로그램 못지않은 강력한 '시스템 응급구조사'가 탄생하게 될 거야. 물론 그 길은 멀고 험하겠지만, 불가능한 꿈은 아니지! 😉

PART 6: 사용자와의 소통 - 인터페이스 만들기 🎨

아무리 기능이 완벽한 자동차라도 핸들이나 페달이 없으면 운전할 수 없겠지? 프로그램도 마찬가지야. 사용자가 프로그램의 강력한 기능을 쉽고 편하게 쓸 수 있도록 만들어주는 '인터페이스(Interface)'가 반드시 필요해. 지금까지는 우리가 코드에 경로를 직접 써넣고 실행했지만, 이제는 사용자가 직접 백업할 폴더와 저장할 위치를 선택할 수 있게 만들어보자.

근본의 멋, CLI (Command-Line Interface)

CLI는 그래픽 화면 없이 오직 텍스트로만 프로그램과 소통하는 방식이야. 해커 영화에 나오는 까만 화면에 초록 글씨, 바로 그거지! 💻 CLI는 보기엔 좀 투박해도, 가볍고 빠르며 자동화 스크립트를 만들기에도 좋아 개발자들에게는 여전히 사랑받는 방식이야.

우리의 백업 프로그램을 CLI 방식으로 개선해 볼 거야. `main` 함수의 `argc`와 `argv`라는 특별한 인자를 사용하면, 프로그램을 실행할 때 추가적인 정보(명령행 인자)를 넘겨받을 수 있어.

예를 들어 터미널에서 이렇게 실행한다면,

backup.exe C:\MyData D:\MyBackup

`argc`는 3이 되고, `argv`는 `{"backup.exe", "C:\MyData", "D:\MyBackup"}` 이라는 배열이 돼.

이 원리를 이용해서 기존의 `main` 함수를 업그레이드해보자.

// main 함수의 인자를 주목!
int main(int argc, char *argv[]) {
    // 인자가 3개가 아니면 (프로그램 이름, 소스, 목적지) 사용법을 알려주고 종료.
    if (argc != 3) {
        printf("=========================================================\n");
        printf("  How to use: %s [Source_Directory] [Destination_Directory]\n", argv[0]);
        printf("  Example: %s \"C:\\Users\\MyUser\\Documents\" \"D:\\Backup\"\n", argv[0]);
        printf("=========================================================\n");
        // 경로에 공백이 있을 수 있으므로 큰따옴표로 감싸주는 것이 좋아.
        return 1; // 비정상 종료
    }

    // argv[1]이 소스 경로, argv[2]가 목적지 경로가 된다.
    char *source = argv[1];
    char *destination = argv[2];

    printf("Starting backup process...\n");
    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    // 기존 백업 함수 호출
    backupDirectory(source, destination);

    printf("\nAll backup tasks are complete! 🎉\n");

    return 0;
}

어때? 이제 코드를 수정하고 매번 다시 컴파일할 필요 없이, 프로그램을 실행할 때마다 원하는 폴더를 자유롭게 백업할 수 있게 됐어. 이것만으로도 훨씬 '프로그램'다워졌지? 여기서 더 나아가 메뉴를 보여주고 사용자에게 번호를 입력받아 백업, 복원, 종료 등의 기능을 선택하게 만들 수도 있어. C언어의 `printf`와 `scanf`만으로도 충분히 근사한 메뉴 기반 CLI 프로그램을 만들 수 있지.

한 단계 위로, GUI (Graphical User Interface)

대부분의 일반 사용자들은 까만 터미널 화면보다는 알록달록한 창과 버튼이 있는 GUI 환경에 훨씬 익숙해. 만약 우리 프로그램을 더 많은 사람이 쓰게 하고 싶다면, GUI를 입히는 것을 고려해봐야 해.

C언어로 GUI를 만드는 건 몇 가지 방법이 있어.

1. 순수한 C와 OS API의 조합 (하드코어):
Windows라면 `Win32 API`, macOS라면 `Cocoa`, 리눅스라면 `Xlib` 같은 운영체제에서 직접 제공하는 API를 사용해서 창을 만들고 버튼을 그리는 방식이야. 운영체제와 한 몸처럼 움직이는 가장 가볍고 빠른 프로그램을 만들 수 있지만, 코드가 매우 복잡하고 운영체제마다 완전히 다른 코드를 짜야 해서 엄청난 노력이 필요해. 💀

2. 크로스플랫폼 GUI 라이브러리 사용 (현실적):
한 번 코드를 짜면 Windows, macOS, Linux 모두에서 동일하게 보이는 GUI 프로그램을 만들 수 있게 해주는 도구 모음(라이브러리)을 사용하는 방법이야.
- GTK+: 리눅스의 대표적인 데스크톱 환경인 GNOME을 만드는 데 사용된 라이브러리. C언어 기반이라 C와 찰떡궁합을 자랑해.
- Qt (C++): 원래 C++ 기반이지만 C언어와 함께 사용하는 것도 가능해. 매우 강력하고 아름다운 UI를 만들 수 있어.
- Dear ImGui: 원래 게임 개발용 UI 라이브러리로 시작했지만, 간단한 툴을 만들 때 빠르고 직관적인 UI를 만들 수 있어서 인기가 많아.

우리의 여정은 C언어의 핵심 로직에 집중했지만, 프로그램의 완성은 결국 사용자와의 '소통'에 있다는 점을 기억해. CLI든 GUI든, 사용자가 내 의도대로 프로그램을 쉽고 안전하게 쓸 수 있도록 안내하는 것이 좋은 개발자의 중요한 덕목 중 하나니까.

PART 7: 최후의 보루 - 부팅 가능한 미디어 만들기 cứu

지금까지 우리가 만든 프로그램은 Windows가 정상적으로 작동하는 상태에서만 실행할 수 있었어. 하지만 진짜 위기는 언제 찾아올까? 바로 Windows 자체가 부팅되지 않을 때야. 이럴 때를 대비한 전문가들의 비장의 무기가 바로 '부팅 가능한 복구 미디어'야. USB나 CD로 부팅해서, 기존 운영체제와는 완전히 독립된 환경에서 시스템을 점검하고 복구하는 거지.

우리가 만든 C언어 프로그램을 이런 '응급 구조 환경'에 탑재할 수 있다면, 그야말로 화룡점정! 진정한 시스템 복구 도구로 거듭나는 거야.

Windows PE: Windows의 미니 버전

Windows PE (Preinstallation Environment)는 Microsoft에서 제공하는, Windows의 핵심 기능만 쏙 뽑아서 만든 아주 가벼운 버전의 Windows야. 원래 목적은 기업에서 대량의 PC에 Windows를 설치하거나 배포하기 위한 것이지만, 시스템 복구 환경을 만드는 데도 아주 훌륭하게 사용돼.

Windows PE 환경의 특징은 다음과 같아:

• 독립적인 부팅: USB나 CD/DVD로 부팅할 수 있어. 메인 하드디스크의 Windows가 완전히 망가져도 상관없어.
• 익숙한 환경: 기본적으로 Windows와 동일한 커널 위에서 동작해. 우리가 만든 C 프로그램(`backup.exe`, `restore.exe`)이 별다른 수정 없이 그대로 실행될 수 있어!
• 필수 도구 포함: 파일 탐색기(는 없지만), 명령 프롬프트, 디스크 관리 도구 등 시스템 복구에 필요한 기본적인 유틸리티를 포함하고 있어.

어떻게 만들까?
Microsoft에서 제공하는 Windows ADK (Assessment and Deployment Kit)라는 도구를 설치하면, Windows PE를 만들고 커스터마이징할 수 있는 환경이 제공돼. 이 환경에서 다음과 같은 작업을 할 수 있어.

1. 기본 Windows PE 이미지 생성. 2. `Dism`이라는 명령어를 사용해서 PE 이미지에 우리가 만든 `backup.exe` 같은 커스텀 프로그램이나 드라이버(예: 특수한 RAID 컨트롤러 드라이버)를 추가. 3. 부팅 시 자동으로 우리 프로그램을 실행하도록 스크립트(`startnet.cmd`) 수정. 4. 완성된 이미지를 `MakeWinPEMedia` 명령어를 사용해서 부팅 가능한 USB로 제작.

이 과정을 거치면, 컴퓨터가 부팅되지 않을 때 이 USB를 꽂고 부팅 순서를 변경하는 것만으로 우리만의 복구 솔루션이 담긴 응급 센터가 열리는 거야. 정말 멋지지 않아? 😎

Live Linux: 자유와 커스터마이징의 끝판왕

또 다른 강력한 대안은 '라이브 리눅스'를 활용하는 거야. Ubuntu, Mint, Arch Linux 등 수많은 리눅스 배포판들은 설치하지 않고도 USB나 CD에서 바로 부팅해서 사용할 수 있는 '라이브' 버전을 제공해.

라이브 리눅스를 복구 미디어로 사용하는 것의 장점은:

• 강력한 도구: 리눅스에는 기본적으로 강력한 파일 시스템 복구 도구(`fsck`, `e2fsck`), 디스크 파티셔닝 도구(`gparted`), 데이터 복구 도구(`testdisk`, `photorec`) 등이 포함되어 있어.
• 높은 자유도: 내가 원하는 어떤 프로그램이든 추가해서 나만의 맞춤형 복구 OS를 만들 수 있어. 우리가 만든 C 프로그램을 리눅스 환경에서 컴파일되도록 약간만 수정(`windows.h` 대신 POSIX 표준 헤더 사용)하면, 리눅스에서도 똑같이 실행할 수 있지.
• Windows 파티션 접근: 리눅스는 Windows가 사용하는 NTFS 파일 시스템을 읽고 쓸 수 있어. 그래서 리눅스로 부팅해서 망가진 Windows 파티션에 접근해 중요한 파일을 백업하는 작업이 가능해.

어떻게 만들까?
`Cubic`이나 `Linux Live Kit` 같은 도구를 사용하면 기존 리눅스 배포판(ISO 파일)을 입맛대로 커스터마이징해서 나만의 라이브 배포판을 쉽게 만들 수 있어. 여기에 우리 프로그램을 기본 탑재하고, 바탕화면에 바로가기 아이콘까지 만들어두면, 누구든 쉽게 사용할 수 있는 전문가용 복구 툴이 탄생하는 거지.

마치며: 우리의 대장정을 돌아보며 🗺️

자, 여기까지 함께 달려오느라 정말 고생 많았어! 우리는 '시스템이 망가지면 어떡하지?'라는 막연한 두려움에서 시작해서, C언어라는 강력한 도구로 그 문제에 정면으로 맞서는 방법을 배웠어.

단순히 파일 목록을 출력하는 작은 프로그램에서 시작해, 재귀 함수를 이용한 정교한 백업/복원 엔진을 만들었고, CLI로 사용자 편의성을 더했지. 더 나아가 부트 로더, 파일 시스템, 레지스트리 같은 시스템의 심장부를 어떻게 다룰 수 있는지 개념을 엿봤고, 마지막에는 Windows PE나 라이브 리눅스로 우리만의 '응급 구조 키트'를 만드는 원대한 계획까지 세워봤어.

물론 우리가 만든 코드는 상용 프로그램에 비하면 아직 걸음마 수준일지도 몰라. 압축 기능도 없고, 속도 최적화나 수많은 예외 처리가 더 필요하겠지. 하지만 중요한 건, 이제 당신은 그 모든 것을 '어떻게' 만들어야 할지 그 방향과 원리를 알게 되었다는 거야. '무엇을 모르는지 아는 것', 이게 바로 전문가로 가는 가장 중요한 첫걸음이거든.

이 프로젝트는 끝이 아니야. 이제 시작이지. 오늘 배운 내용을 바탕으로:

• 백업 파일에 버전 관리 기능을 추가해볼 수도 있고,
• zlib 같은 라이브러리를 연동해서 압축 백업 기능을 구현해볼 수도 있으며,
• 네트워크를 통해 다른 컴퓨터에 백업하는 기능을 만들어볼 수도 있어.

프로그래밍의 진짜 재미는 이렇게 내가 만든 창조물에 새로운 생명을 불어넣고, 끊임없이 발전시켜 나가는 과정에 있어. 혼자 하기 벅차다면, 주변의 동료나 스터디 그룹, 혹은 재능넷과 같은 플랫폼에서 당신의 프로젝트에 영감을 주거나 도움을 줄 수 있는 새로운 인연을 만나보는 것도 좋은 방법이야.

이제 당신의 컴퓨터에 블루스크린이 떠도 예전처럼 당황하지 않을 거야. 오히려 "흠, 어디가 고장 났는지 한번 볼까?" 하고 자신감 있게 문제에 다가설 수 있게 됐을 테니까. 당신의 손으로 직접 만든 코드가 누군가의 소중한 데이터, 혹은 당신 자신의 위기를 구해낼 그날을 상상해봐. 정말 가슴 뛰는 일 아니야? 😉

지금까지 긴 여정을 함께해 줘서 고마워. 당신의 키보드 위에서 또 다른 위대한 창조가 시작되기를 진심으로 응원할게! Happy Coding! 🚀