C언어에서 파일 포인터를 활용한 네트워크 로그 저장 방법

   FILE *fp = fopen("log.txt", "w");
   if (fp == NULL) {
       perror("파일 열기 실패");
       return 1;
   }

   fprintf(fp, "네트워크 로그 시작\n");

   fclose(fp);

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

int main() {
    FILE *logFile;
    time_t now;
    char *timestamp;

    // 1. 파일 열기
    logFile = fopen("network_log.txt", "a");
    if (logFile == NULL) {
        perror("파일 열기 실패");
        return 1;
    }

    // 2. 현재 시간 가져오기
    time(&now);
    timestamp = ctime(&now);  // 현재 시간을 문자열로 변환
    timestamp[strcspn(timestamp, "\n")] = 0;  // 개행 문자 제거

    // 3. 로그 쓰기
    fprintf(logFile, "[%s] 네트워크 연결 성공: 192.168.1.1\n", timestamp);
    fprintf(logFile, "[%s] 데이터 전송 완료: 512KB\n", timestamp);

    // 4. 파일 닫기
    fclose(logFile);

    printf("네트워크 로그가 저장되었습니다.\n");
    return 0;
}

[2025-01-03 12:34:56] 네트워크 연결 성공: 192.168.1.1  
[2025-01-03 12:34:56] 데이터 전송 완료: 512KB  

[2025-01-03 12:34:56] INFO CONNECTION_SUCCESS IP: 192.168.1.1  
[2025-01-03 12:35:00] INFO DATA_TRANSFER IP: 192.168.1.1, Data: 512KB  
[2025-01-03 12:36:05] ERROR CONNECTION_TIMEOUT IP: 192.168.1.1  

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

void writeLog(const char *level, const char *eventType, const char *details) {
    FILE *logFile;
    time_t now;
    char *timestamp;

    // 파일 열기
    logFile = fopen("network_log.txt", "a");
    if (logFile == NULL) {
        perror("로그 파일 열기 실패");
        return;
    }

    // 타임스탬프 생성
    time(&now);
    timestamp = ctime(&now);
    timestamp[strcspn(timestamp, "\n")] = 0;  // 개행 문자 제거

    // 로그 쓰기
    fprintf(logFile, "[%s] %s %s %s\n", timestamp, level, eventType, details);

    // 파일 닫기
    fclose(logFile);
}

int main() {
    // 로그 예제
    writeLog("INFO", "CONNECTION_SUCCESS", "IP: 192.168.1.1");
    writeLog("INFO", "DATA_TRANSFER", "IP: 192.168.1.1, Data: 512KB");
    writeLog("ERROR", "CONNECTION_TIMEOUT", "IP: 192.168.1.1");

    printf("네트워크 로그가 저장되었습니다.\n");
    return 0;
}

  {"timestamp": "2025-01-03 12:34:56", "level": "INFO", "event": "CONNECTION_SUCCESS", "details": "IP: 192.168.1.1"}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define BUFFER_SIZE 1024  // 메모리 버퍼 크기

void logToFile(FILE *file, const char *buffer) {
    if (file == NULL || buffer == NULL) {
        return;
    }
    fprintf(file, "%s", buffer);
}

int main() {
    FILE *logFile;
    char *buffer;
    size_t bufferSize = BUFFER_SIZE;
    size_t currentSize = 0;

    // 파일 열기
    logFile = fopen("network_log.txt", "a");
    if (logFile == NULL) {
        perror("파일 열기 실패");
        return 1;
    }

    // 메모리 할당
    buffer = (char *)malloc(bufferSize);
    if (buffer == NULL) {
        perror("메모리 할당 실패");
        fclose(logFile);
        return 1;
    }

    // 로그 생성 및 저장
    for (int i = 0; i < 10; i++) {
        char logEntry[128];
        time_t now = time(NULL);
        snprintf(logEntry, sizeof(logEntry), "[%s] INFO EVENT %d\n", ctime(&now), i + 1);

        size_t entryLength = strlen(logEntry);
        if (currentSize + entryLength > bufferSize) {
            // 버퍼가 가득 찬 경우 파일로 플러시
            logToFile(logFile, buffer);
            currentSize = 0;
        }
        // 로그를 버퍼에 저장
        memcpy(buffer + currentSize, logEntry, entryLength);
        currentSize += entryLength;
    }

    // 남은 로그 플러시
    if (currentSize > 0) {
        logToFile(logFile, buffer);
    }

    // 자원 해제
    free(buffer);
    fclose(logFile);

    printf("로그가 성공적으로 저장되었습니다.\n");
    return 0;
}

   FILE *file = fopen("log.txt", "r");
   if (file == NULL) {
       perror("파일 열기 실패");
       return 1;
   }

   if (fprintf(file, "로그 내용\n") < 0) {
       perror("파일 쓰기 실패");
   }

   if (fclose(file) != 0) {
       perror("파일 닫기 실패");
   }

#include <stdio.h>
#include <errno.h>

int main() {
    FILE *file;

    // 파일 열기
    file = fopen("log.txt", "a");
    if (file == NULL) {
        perror("파일 열기 실패");
        return 1;
    }

    // 파일 쓰기
    if (fprintf(file, "로그 내용 저장\n") < 0) {
        perror("파일 쓰기 실패");
        fclose(file); // 오류 발생 시에도 파일 닫기 시도
        return 1;
    }

    // 파일 닫기
    if (fclose(file) != 0) {
        perror("파일 닫기 실패");
        return 1;
    }

    printf("파일 입출력이 성공적으로 완료되었습니다.\n");
    return 0;
}

   setvbuf(file, NULL, _IOFBF, 1024); // 1KB 버퍼 설정

   char filename[128];
   snprintf(filename, sizeof(filename), "network_log_%Y%m%d.txt", time(NULL));
   FILE *file = fopen(filename, "a");

   long maxFileSize = 1024 * 1024; // 1MB
   if (ftell(file) > maxFileSize) {
       fclose(file);
       file = fopen("new_log.txt", "a");
   }

   void logMessage(FILE *file, const char *level, const char *message) {
       if (strcmp(level, "INFO") == 0 || strcmp(level, "ERROR") == 0) {
           fprintf(file, "[%s] %s\n", level, message);
       }
   }

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

#define MAX_LOG_SIZE 1024 * 1024  // 1MB

void writeLog(FILE **file, const char *filename, const char *message) {
    // 파일 크기 확인
    fseek(*file, 0, SEEK_END);
    if (ftell(*file) > MAX_LOG_SIZE) {
        fclose(*file);
        *file = fopen(filename, "a"); // 새 파일 열기
    }

    // 로그 쓰기
    fprintf(*file, "%s\n", message);
}

int main() {
    FILE *logFile = fopen("network_log.txt", "a");
    if (logFile == NULL) {
        perror("로그 파일 열기 실패");
        return 1;
    }

    // 로그 기록
    writeLog(&logFile, "network_log.txt", "[INFO] 네트워크 연결 성공");
    writeLog(&logFile, "network_log.txt", "[ERROR] 데이터 전송 실패");

    fclose(logFile);
    return 0;
}

   pthread_mutex_t lock;
   pthread_mutex_lock(&lock);
   fprintf(file, "동기화된 로그\n");
   pthread_mutex_unlock(&lock);

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

#define QUEUE_SIZE 100

typedef struct {
    char *messages[QUEUE_SIZE];
    int front, rear, count;
    pthread_mutex_t lock;
    pthread_cond_t notEmpty;
} LogQueue;

LogQueue logQueue;
FILE *logFile;

// 큐 초기화
void initQueue(LogQueue *queue) {
    queue->front = queue->rear = queue->count = 0;
    pthread_mutex_init(&queue->lock, NULL);
    pthread_cond_init(&queue->notEmpty, NULL);
}

// 큐에 메시지 추가
void enqueue(LogQueue *queue, const char *message) {
    pthread_mutex_lock(&queue->lock);

    if (queue->count < QUEUE_SIZE) {
        queue->messages[queue->rear] = strdup(message);
        queue->rear = (queue->rear + 1) % QUEUE_SIZE;
        queue->count++;
        pthread_cond_signal(&queue->notEmpty);
    }

    pthread_mutex_unlock(&queue->lock);
}

// 큐에서 메시지 제거
char *dequeue(LogQueue *queue) {
    pthread_mutex_lock(&queue->lock);

    while (queue->count == 0) {
        pthread_cond_wait(&queue->notEmpty, &queue->lock);
    }

    char *message = queue->messages[queue->front];
    queue->front = (queue->front + 1) % QUEUE_SIZE;
    queue->count--;

    pthread_mutex_unlock(&queue->lock);
    return message;
}

// 로그 쓰기 쓰레드
void *logWriter(void *arg) {
    while (1) {
        char *message = dequeue(&logQueue);
        fprintf(logFile, "%s\n", message);
        free(message);
        fflush(logFile); // 실시간 기록
    }
    return NULL;
}

int main() {
    // 로그 파일 열기
    logFile = fopen("network_log.txt", "a");
    if (logFile == NULL) {
        perror("파일 열기 실패");
        return 1;
    }

    // 큐 초기화
    initQueue(&logQueue);

    // 쓰레드 생성
    pthread_t writerThread;
    pthread_create(&writerThread, NULL, logWriter, NULL);

    // 로그 메시지 생성
    for (int i = 0; i < 10; i++) {
        char message[128];
        snprintf(message, sizeof(message), "[INFO] 로그 메시지 %d", i + 1);
        enqueue(&logQueue, message);
        sleep(1); // 메시지 간 간격
    }

    // 종료 전 대기 (테스트용)
    sleep(5);

    // 리소스 정리
    fclose(logFile);
    return 0;
}