C언어에서 시그널 핸들러로 커스텀 에러 메시지 출력하기

C언어는 시스템 프로그래밍에서 높은 성능과 제어를 제공하지만, 비정상 종료 상황을 효과적으로 처리하지 않으면 프로그램 안정성이 저하될 수 있습니다. 시그널 핸들러는 이러한 상황에 대처할 수 있는 강력한 도구로, 예외적인 시그널이 발생했을 때 사용자 정의 동작을 수행할 수 있습니다. 본 기사에서는 C언어에서 시그널 핸들러를 활용해 커스텀 에러 메시지를 출력하는 방법과 실용적인 활용 사례를 자세히 다룹니다.

시그널 핸들러의 기본 개념

시그널 핸들러는 운영 체제에서 프로그램에 특정 이벤트가 발생했음을 알리기 위해 사용되는 메커니즘입니다. 프로그램이 실행 중 특정 시그널을 받으면, 사전에 정의된 핸들러 함수가 호출되어 해당 이벤트를 처리합니다.

시그널 핸들러의 동작

시그널은 소프트웨어 인터럽트의 일종으로, 특정 조건이 충족되었을 때 운영 체제가 프로세스에 전달합니다. 예를 들어, 잘못된 메모리 접근(SIGSEGV)이나 나누기 연산 오류(SIGFPE) 등이 시그널의 예입니다. 시그널 핸들러를 설정하면 기본 동작 대신 사용자가 정의한 동작을 실행할 수 있습니다.

핸들러 함수의 특징

반드시 void 반환형: 시그널 핸들러 함수는 void 반환형이어야 합니다.
하나의 매개변수: 핸들러는 발생한 시그널 번호를 매개변수로 받습니다.
비동기 실행: 시그널 핸들러는 프로그램의 실행 흐름과 독립적으로 동작합니다.

예제: 간단한 시그널 핸들러

#include <stdio.h>
#include <signal.h>

// 핸들러 함수 정의
void signal_handler(int signal) {
    printf("Received signal: %d\n", signal);
}

int main() {
    // SIGINT 시그널에 대해 핸들러 등록
    signal(SIGINT, signal_handler);

    while (1) {
        printf("Running...\n");
        sleep(1);
    }
    return 0;
}

이 코드에서 SIGINT 시그널이 발생하면(예: Ctrl+C 입력), 커스텀 핸들러가 호출됩니다. 이는 프로그램의 기본 종료 동작을 대체합니다.

C언어에서의 시그널의 종류

C언어에서는 운영 체제에서 발생하는 다양한 시그널을 처리할 수 있습니다. 각 시그널은 특정한 이벤트를 나타내며, 시그널 핸들러를 통해 이러한 이벤트를 커스터마이징할 수 있습니다.

주요 시그널과 의미

SIGINT

의미: 인터럽트 시그널. 주로 키보드에서 Ctrl+C 입력 시 발생.
기본 동작: 프로그램 종료.

SIGSEGV

의미: 잘못된 메모리 접근 시 발생(세그멘테이션 오류).
기본 동작: 프로그램 종료.

SIGFPE

의미: 부동소수점 연산 오류(0으로 나누기, 오버플로 등).
기본 동작: 프로그램 종료.

SIGTERM

의미: 종료 요청 시그널. 주로 kill 명령을 통해 전달.
기본 동작: 프로그램 종료.

SIGHUP

의미: 프로세스의 연결이 끊어졌을 때 발생(예: 터미널 종료).
기본 동작: 프로그램 종료.

SIGKILL

의미: 강제 종료 시그널.
기본 동작: 강제 프로그램 종료(핸들러 등록 불가능).

SIGUSR1 및 SIGUSR2

의미: 사용자 정의 시그널. 특정 동작을 프로그래머가 정의 가능.
기본 동작: 없음(사용자 정의 필요).

시그널 번호

시그널은 운영 체제에 따라 번호로 매핑되며, 이는 시스템에 따라 달라질 수 있습니다. 예를 들어, Linux에서는 SIGINT가 일반적으로 2번, SIGKILL이 9번으로 할당됩니다.

예제: 시그널 종류 확인

#include <signal.h>
#include <stdio.h>

int main() {
    printf("SIGINT: %d\n", SIGINT);
    printf("SIGSEGV: %d\n", SIGSEGV);
    printf("SIGFPE: %d\n", SIGFPE);
    printf("SIGTERM: %d\n", SIGTERM);
    return 0;
}

이 코드를 실행하면 현재 시스템에서 각 시그널의 번호를 확인할 수 있습니다.

핵심 포인트

모든 시그널이 핸들러로 처리 가능한 것은 아닙니다(SIGKILL 및 SIGSTOP 등 예외 존재).
각 시그널은 특정한 이벤트와 연결되며, 적절한 핸들링을 통해 프로그램의 안정성을 높일 수 있습니다.

시그널 핸들러 구현 방법

C언어에서 시그널 핸들러를 구현하려면, 특정 시그널이 발생했을 때 실행될 핸들러 함수를 정의하고 이를 시스템에 등록해야 합니다. 이를 통해 기본 시그널 처리 동작을 사용자 정의 동작으로 대체할 수 있습니다.

핸들러 함수 정의

핸들러 함수는 시그널 번호를 매개변수로 받으며, 반환형은 void입니다. 함수 내에서 시그널 발생 시 수행할 동작을 정의합니다.

#include <stdio.h>
#include <signal.h>

void my_signal_handler(int signal) {
    printf("Signal %d received.\n", signal);
}

위 예제에서 my_signal_handler는 시그널 번호를 출력합니다.

핸들러 등록 방법

시그널 핸들러를 등록하려면 signal 함수를 사용합니다.

#include <signal.h>

signal(SIGINT, my_signal_handler);

첫 번째 인자: 처리할 시그널의 종류(예: SIGINT).
두 번째 인자: 호출할 핸들러 함수의 이름.

핸들러 제거

시그널 핸들러를 제거하고 기본 동작으로 되돌리려면 SIG_DFL을 사용합니다.

signal(SIGINT, SIG_DFL);

핸들러를 무시하려면 SIG_IGN을 사용할 수 있습니다.

signal(SIGINT, SIG_IGN);

완전한 구현 예제

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// 사용자 정의 핸들러 함수
void handle_sigint(int signal) {
    printf("Custom handler: Signal %d received. Exiting...\n", signal);
    _exit(0); // 안전하게 프로그램 종료
}

int main() {
    // SIGINT에 대해 핸들러 등록
    signal(SIGINT, handle_sigint);

    // 무한 루프 실행
    while (1) {
        printf("Running... Press Ctrl+C to trigger SIGINT\n");
        sleep(1);
    }

    return 0;
}

코드 설명

signal(SIGINT, handle_sigint)로 SIGINT 시그널에 대해 사용자 정의 핸들러를 등록.
Ctrl+C를 누르면 SIGINT가 발생하고 핸들러가 호출됨.
핸들러에서 메시지를 출력한 후 프로그램이 안전하게 종료.

주의 사항

핸들러 함수 내에서 복잡한 작업(예: 동적 메모리 할당)은 피하는 것이 좋습니다.
시그널 처리 중 일부 시스템 호출은 중단될 수 있으므로 적절히 복구해야 합니다.

핸들러 등록 시 유의점

signal 함수는 간단하지만 일부 시스템에서는 예상치 못한 동작을 할 수 있습니다. 보다 안전한 sigaction 함수 사용이 권장되기도 합니다.
시그널의 기본 동작과 핸들러 등록이 충돌하지 않도록 설계해야 합니다.

커스텀 에러 메시지 출력 기법

시그널 핸들러를 사용하여 발생한 시그널에 따라 커스텀 에러 메시지를 출력하면, 디버깅과 문제 해결에 유용한 정보를 제공할 수 있습니다. 이 과정에서는 시그널 번호와 관련 메시지를 핸들러 내부에서 출력하거나, 동적으로 메시지를 생성하여 사용자 정의 동작을 수행합니다.

기본적인 커스텀 메시지 출력

핸들러 함수 내에서 printf를 사용하여 시그널 번호와 간단한 메시지를 출력할 수 있습니다.

#include <stdio.h>
#include <signal.h>

void custom_signal_handler(int signal) {
    if (signal == SIGSEGV) {
        printf("Error: Segmentation Fault (SIGSEGV) occurred.\n");
    } else if (signal == SIGFPE) {
        printf("Error: Floating-point Exception (SIGFPE) occurred.\n");
    } else {
        printf("Error: Signal %d received.\n", signal);
    }
}

시그널 번호에 따른 메시지 매핑

더 많은 시그널에 대해 메시지를 다루기 위해 배열을 활용해 메시지를 관리할 수 있습니다.

#include <stdio.h>
#include <signal.h>

void signal_handler_with_mapping(int signal) {
    const char *messages[] = {
        [SIGINT] = "Interrupt from keyboard (SIGINT)",
        [SIGSEGV] = "Segmentation fault (SIGSEGV)",
        [SIGFPE] = "Floating-point exception (SIGFPE)",
        [SIGTERM] = "Termination signal (SIGTERM)"
    };

    if (signal < sizeof(messages) / sizeof(messages[0]) && messages[signal]) {
        printf("Error: %s\n", messages[signal]);
    } else {
        printf("Error: Unknown signal %d received.\n", signal);
    }
}

이 방법은 새로운 시그널에 대한 메시지를 추가할 때 코드 유지보수를 용이하게 만듭니다.

동적 메시지 생성

프로그램 실행 상태에 따라 동적인 에러 메시지를 생성할 수도 있습니다.

#include <stdio.h>
#include <signal.h>

void dynamic_message_handler(int signal) {
    char custom_message[100];
    snprintf(custom_message, sizeof(custom_message), "Custom Error: Signal %d occurred. Please check the system.", signal);
    printf("%s\n", custom_message);
}

이 방식은 실행 중 수집한 정보를 기반으로 세부적인 메시지를 출력할 수 있습니다.

구체적인 활용: 디버깅 로그 출력

커스텀 메시지를 출력하면서 디버깅 로그를 파일에 저장하여 문제가 발생한 시점을 기록할 수 있습니다.

#include <stdio.h>
#include <signal.h>
#include <time.h>

void log_signal(int signal) {
    FILE *log_file = fopen("error_log.txt", "a");
    if (!log_file) {
        printf("Error: Unable to open log file.\n");
        return;
    }

    time_t current_time = time(NULL);
    fprintf(log_file, "Signal %d received at %s", signal, ctime(&current_time));
    fclose(log_file);

    printf("Error: Signal %d logged to file.\n", signal);
}

핵심 포인트

시그널에 따라 구체적이고 이해하기 쉬운 메시지를 출력해야 합니다.
사용자 정의 메시지는 디버깅과 프로그램 동작 분석에 도움을 줍니다.
필요할 경우 메시지를 로그 파일로 저장하여 장기적인 분석 자료로 활용할 수 있습니다.

시그널 처리 코드 작성 실습

시그널 핸들러를 설정하고, 커스텀 에러 메시지를 출력하는 간단한 코드를 작성하여 실습합니다. 이를 통해 시그널 발생 시 핸들러가 호출되고, 사용자 정의 동작이 수행되는 과정을 익힙니다.

실습 목표

시그널 핸들러 설정 및 호출 확인.
시그널에 따른 커스텀 메시지 출력.
프로그램의 비정상 종료 방지.

예제 코드: SIGINT와 SIGFPE 처리

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// 사용자 정의 시그널 핸들러
void custom_signal_handler(int signal) {
    switch (signal) {
        case SIGINT:
            printf("\nCustom Handler: Program interrupted (SIGINT).\n");
            break;
        case SIGFPE:
            printf("Custom Handler: Floating-point exception (SIGFPE) occurred.\n");
            break;
        default:
            printf("Custom Handler: Unknown signal %d received.\n", signal);
    }
}

int main() {
    // SIGINT와 SIGFPE에 대해 핸들러 등록
    signal(SIGINT, custom_signal_handler);
    signal(SIGFPE, custom_signal_handler);

    // 무한 루프 실행 (SIGINT 테스트)
    printf("Press Ctrl+C to trigger SIGINT or divide by zero to trigger SIGFPE.\n");
    while (1) {
        int a = 5, b = 0;
        sleep(3);

        // SIGFPE 테스트
        printf("Dividing %d by %d...\n", a, b);
        if (b == 0) {
            raise(SIGFPE);  // 강제로 SIGFPE 발생
        }
    }

    return 0;
}

코드 설명

핸들러 등록: signal 함수를 사용해 SIGINT(Ctrl+C)와 SIGFPE(0으로 나누기) 처리 핸들러를 등록.
핸들러 동작: 시그널 발생 시 해당 메시지를 출력.
SIGFPE 테스트: raise(SIGFPE)를 사용해 강제로 시그널 발생.

실행 및 결과

Ctrl+C 입력:

  Press Ctrl+C to trigger SIGINT or divide by zero to trigger SIGFPE.
  ^C
  Custom Handler: Program interrupted (SIGINT).

강제 SIGFPE 발생:

  Press Ctrl+C to trigger SIGINT or divide by zero to trigger SIGFPE.
  Dividing 5 by 0...
  Custom Handler: Floating-point exception (SIGFPE) occurred.

확장 실습

추가 시그널(예: SIGTERM, SIGUSR1) 처리 핸들러를 등록하고 메시지를 출력해보세요.
로그 파일 작성 기능을 추가해 시그널 발생 시점을 기록해보세요.

학습 포인트

시그널 핸들러 구현과 설정 과정을 실습하며, 비정상 상황에 대비하는 코드를 작성할 수 있습니다.
다양한 시그널의 발생 조건을 실험하며, 시스템 수준 프로그래밍의 개념을 익힙니다.

응용 사례: 오류 로그 파일 작성

커스텀 에러 메시지를 활용하여 발생한 시그널 이벤트를 로그 파일에 저장하면, 비정상 종료 상황을 추적하고 디버깅에 유용한 정보를 얻을 수 있습니다. 이 섹션에서는 시그널 핸들러를 사용해 로그 파일을 작성하는 방법을 살펴봅니다.

로그 파일 작성 기본 구조

시그널 발생 시 현재 시간을 포함한 상세 정보를 기록합니다.
파일 입출력을 안전하게 처리하여 로그 손실을 방지합니다.
파일을 열고 닫는 작업을 효율적으로 관리합니다.

예제 코드: 로그 파일 작성 핸들러

#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>

// 로그 파일 작성 핸들러 함수
void log_signal_handler(int signal) {
    FILE *log_file = fopen("signal_log.txt", "a");  // 로그 파일을 추가 모드로 열기
    if (!log_file) {
        printf("Error: Unable to open log file.\n");
        return;
    }

    // 현재 시간 가져오기
    time_t current_time = time(NULL);
    char *time_str = ctime(&current_time);
    if (time_str) {
        time_str[strcspn(time_str, "\n")] = '\0';  // 개행 문자 제거
    }

    // 로그 작성
    fprintf(log_file, "[%s] Signal %d received.\n", time_str, signal);
    fclose(log_file);

    // 사용자에게 알림
    printf("Signal %d logged to file.\n", signal);
}

int main() {
    // SIGINT와 SIGTERM에 대한 핸들러 등록
    signal(SIGINT, log_signal_handler);
    signal(SIGTERM, log_signal_handler);

    printf("Running... Press Ctrl+C to trigger SIGINT or use 'kill -TERM [PID]' to send SIGTERM.\n");

    // 무한 루프 실행
    while (1) {
        sleep(1);
    }

    return 0;
}

코드 설명

파일 열기: fopen으로 로그 파일을 추가 모드("a")로 열어 시그널 발생 시 데이터를 계속 추가합니다.
시간 기록: time과 ctime을 사용해 시그널 발생 시의 시간을 로그에 포함.
로그 작성: fprintf를 통해 시그널 번호와 발생 시점을 기록.
파일 닫기: fclose로 파일을 닫아 리소스를 효율적으로 관리.

실행 및 결과

프로그램 실행 후 Ctrl+C를 누르면 signal_log.txt 파일에 로그가 추가됩니다.

   [2025-01-08 15:00:00] Signal 2 received.

kill -TERM [PID] 명령으로 SIGTERM 시그널을 보내면 다음과 같은 로그가 추가됩니다.

   [2025-01-08 15:01:00] Signal 15 received.

응용 포인트

다중 시그널 처리: 발생한 시그널 유형별로 다른 메시지를 로그에 기록할 수 있습니다.
시스템 상태 기록: 시그널 발생 시 메모리 사용량, 열려 있는 파일 등의 추가 정보를 기록하여 디버깅을 용이하게 할 수 있습니다.

확장 연습

로그 파일에 프로그램 상태(예: 변수 값, 스택 상태)를 기록하는 기능을 추가하세요.
로그 파일 이름에 날짜와 시간을 포함하여 여러 실행 로그를 구분하세요.

이 응용 사례는 비정상 상황에서 문제를 진단하고 분석하는 데 매우 효과적인 방법입니다.

요약

본 기사에서는 C언어에서 시그널 핸들러를 활용해 커스텀 에러 메시지를 출력하고, 로그 파일을 작성하는 방법을 다루었습니다.

핸들러 기본 구현: 시그널의 기본 동작을 대체하여 사용자 정의 메시지를 출력.
주요 시그널 설명: SIGINT, SIGFPE, SIGTERM 등 다양한 시그널의 발생 조건과 의미를 학습.
로그 작성 응용: 시그널 발생 시점을 파일에 저장하여 문제를 추적.

시그널 핸들러는 비정상 상황에서 안정적으로 프로그램을 관리하고 디버깅을 돕는 강력한 도구입니다. 이를 활용하면 소프트웨어의 안정성과 유지보수성을 대폭 향상시킬 수 있습니다.