MENU
  1. ホーム
  2. C 언어
  3. C 언어로 소켓을 활용한 파일 전송 프로그램 구현

C 언어로 소켓을 활용한 파일 전송 프로그램 구현

C 언어

C 언어에서 소켓을 활용한 파일 전송은 네트워크 프로그래밍의 기초적인 응용 중 하나입니다. 소켓 프로그래밍을 통해 네트워크 상에서 데이터를 주고받을 수 있으며, 이를 파일 전송 프로그램으로 구현하면 실제 애플리케이션 개발에 필요한 기술을 익힐 수 있습니다. 이 기사에서는 소켓의 기본 개념부터 TCP 기반의 파일 전송 구현, 오류 처리, 그리고 최적화까지 단계적으로 설명합니다.

목차
  1. 소켓 프로그래밍의 기본 개념
    1. 소켓의 정의
    2. 소켓의 동작 원리
    3. 주요 함수
  2. TCP와 UDP의 차이
    1. TCP(Transmission Control Protocol)
    2. UDP(User Datagram Protocol)
    3. 파일 전송에 적합한 프로토콜
  3. 파일 전송을 위한 소켓 초기화
    1. 서버에서의 소켓 초기화
    2. 클라이언트에서의 소켓 초기화
    3. 결론
  4. 데이터 송수신 메커니즘
    1. 데이터 송신
    2. 데이터 수신
    3. 송수신의 핵심 함수
    4. 버퍼 관리와 전송 종료
    5. 전송 프로토콜 설계
  5. 파일 분할 전송 기법
    1. 분할 전송의 필요성
    2. 분할 전송 구현
    3. 파일 크기 정보 송수신
    4. 전송 종료 신호
    5. 결론
  6. 전송 중 오류 처리
    1. 오류의 주요 유형
    2. 오류 처리 방법
    3. 전송 실패 처리
    4. 로그 기록
    5. 결론
  7. 클라이언트-서버 모델 구현 예시
    1. 서버 코드
    2. 클라이언트 코드
    3. 결론
  8. 테스트 및 디버깅
    1. 테스트 계획
    2. 디버깅 팁
    3. 결과 분석 및 최적화
    4. 결론
  9. 요약

소켓 프로그래밍의 기본 개념


소켓은 네트워크 상에서 데이터 통신을 가능하게 하는 소프트웨어 인터페이스입니다. 소켓을 통해 애플리케이션은 네트워크 프로토콜을 사용하여 데이터를 송수신할 수 있습니다.

소켓의 정의


소켓은 네트워크 통신의 끝점을 나타내는 추상화된 개념으로, IP 주소와 포트 번호를 사용하여 네트워크 상의 특정 서비스를 식별합니다.

소켓의 동작 원리

  • 생성: socket() 함수를 호출하여 소켓을 생성합니다.
  • 바인딩: bind() 함수로 소켓에 IP 주소와 포트를 할당합니다.
  • 연결: 클라이언트는 connect() 함수로 서버에 연결을 요청하고, 서버는 listen()과 accept()를 사용해 연결 요청을 처리합니다.
  • 데이터 송수신: send()와 recv() 또는 write()와 read() 함수로 데이터를 주고받습니다.

주요 함수

  • socket(): 소켓 생성
  • bind(): 소켓에 주소를 연결
  • listen(): 서버 소켓 대기 상태 설정
  • accept(): 클라이언트 연결 수락
  • connect(): 클라이언트에서 서버로 연결 요청
  • send() / recv(): 데이터 송수신

이 기본 개념과 동작 원리를 이해하면 네트워크 프로그래밍의 핵심을 파악할 수 있습니다.

TCP와 UDP의 차이


파일 전송에 적합한 프로토콜을 선택하기 위해 TCP와 UDP의 특성과 차이를 이해하는 것이 중요합니다.

TCP(Transmission Control Protocol)


TCP는 연결 지향 프로토콜로, 데이터의 신뢰성과 순서를 보장합니다.

  • 장점:
  • 데이터 전송의 신뢰성 보장 (패킷 손실 시 재전송)
  • 데이터의 순서 보장
  • 연결 확인 과정으로 안정적인 통신 제공
  • 단점:
  • 추가적인 연결 설정 및 관리로 인해 오버헤드 증가
  • 속도가 UDP에 비해 느릴 수 있음

UDP(User Datagram Protocol)


UDP는 비연결형 프로토콜로, 데이터의 순서와 신뢰성을 보장하지 않습니다.

  • 장점:
  • 연결 설정 없이 빠른 데이터 전송
  • 오버헤드가 적어 실시간 전송에 적합
  • 단점:
  • 패킷 손실 시 데이터 복구 불가능
  • 데이터 순서가 보장되지 않음

파일 전송에 적합한 프로토콜


파일 전송 프로그램에서는 TCP가 주로 사용됩니다.

  • 이유: 데이터의 신뢰성과 순서를 보장하기 때문에 파일 전송 중 데이터 손실이나 순서 오류를 방지할 수 있습니다.
  • UDP는 실시간 통신이나 전송 속도가 중요한 애플리케이션(예: 스트리밍)에 적합합니다.

적절한 프로토콜 선택은 프로그램의 목적과 요구사항에 따라 달라질 수 있습니다.

파일 전송을 위한 소켓 초기화


소켓 초기화는 서버와 클라이언트 간의 안정적인 통신을 설정하는 첫 번째 단계입니다. 이 과정에서 소켓을 생성하고, 필요한 경우 바인딩, 연결 설정 등을 수행합니다.

서버에서의 소켓 초기화

  1. 소켓 생성
    socket() 함수를 호출하여 소켓을 생성합니다.
   int server_socket = socket(AF_INET, SOCK_STREAM, 0);
   if (server_socket == -1) {
       perror("Socket creation failed");
       exit(1);
   }
  1. 소켓 바인딩
    생성된 소켓을 특정 IP 주소와 포트에 연결합니다.
   struct sockaddr_in server_addr;
   server_addr.sin_family = AF_INET;
   server_addr.sin_port = htons(8080); // 포트 번호 설정
   server_addr.sin_addr.s_addr = INADDR_ANY; // 모든 네트워크 인터페이스에서 연결 수락

   if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
       perror("Binding failed");
       close(server_socket);
       exit(1);
   }
  1. 연결 대기
    클라이언트 연결 요청을 대기 상태로 설정합니다.
   if (listen(server_socket, 5) == -1) {
       perror("Listening failed");
       close(server_socket);
       exit(1);
   }
  1. 클라이언트 연결 수락
    클라이언트의 연결 요청을 수락하여 통신을 시작합니다.
   int client_socket = accept(server_socket, NULL, NULL);
   if (client_socket == -1) {
       perror("Connection acceptance failed");
       close(server_socket);
       exit(1);
   }

클라이언트에서의 소켓 초기화

  1. 소켓 생성
    서버와 동일하게 socket()을 사용하여 소켓을 생성합니다.
   int client_socket = socket(AF_INET, SOCK_STREAM, 0);
   if (client_socket == -1) {
       perror("Socket creation failed");
       exit(1);
   }
  1. 서버 연결
    connect() 함수를 사용하여 서버에 연결을 요청합니다.
   struct sockaddr_in server_addr;
   server_addr.sin_family = AF_INET;
   server_addr.sin_port = htons(8080);
   inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 서버 IP 주소 설정

   if (connect(client_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
       perror("Connection failed");
       close(client_socket);
       exit(1);
   }

결론


서버와 클라이언트 모두 소켓 초기화를 올바르게 설정해야 통신이 가능합니다. 이 초기화 과정을 통해 양측이 데이터를 주고받을 준비를 완료할 수 있습니다.

데이터 송수신 메커니즘


파일 전송 프로그램에서는 데이터를 송수신하는 과정이 핵심입니다. 서버와 클라이언트는 소켓을 통해 데이터를 주고받으며, 이를 위해 송수신 함수와 적절한 버퍼 관리가 필요합니다.

데이터 송신


클라이언트 또는 서버가 파일 데이터를 읽어 소켓을 통해 전송합니다.

void send_file(int socket, const char *file_path) {
    FILE *file = fopen(file_path, "rb");
    if (file == NULL) {
        perror("File open failed");
        return;
    }

    char buffer[1024];
    size_t bytes_read;

    while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
        if (send(socket, buffer, bytes_read, 0) == -1) {
            perror("Data send failed");
            break;
        }
    }

    fclose(file);
    printf("File sent successfully.\n");
}

데이터 수신


파일 데이터를 소켓에서 읽어와 파일로 저장합니다.

void receive_file(int socket, const char *output_path) {
    FILE *file = fopen(output_path, "wb");
    if (file == NULL) {
        perror("File open failed");
        return;
    }

    char buffer[1024];
    ssize_t bytes_received;

    while ((bytes_received = recv(socket, buffer, sizeof(buffer), 0)) > 0) {
        fwrite(buffer, 1, bytes_received, file);
    }

    if (bytes_received == -1) {
        perror("Data receive failed");
    } else {
        printf("File received successfully.\n");
    }

    fclose(file);
}

송수신의 핵심 함수

  • send(socket, buffer, length, flags): 지정된 소켓에 데이터를 전송합니다.
  • recv(socket, buffer, length, flags): 지정된 소켓에서 데이터를 수신합니다.

버퍼 관리와 전송 종료

  • 버퍼 크기: 적절한 크기의 버퍼를 사용하여 전송 효율을 높입니다(일반적으로 1KB~64KB).
  • 전송 종료: 파일 전송이 끝났음을 알리기 위해 파일 크기 또는 EOF를 활용합니다.

전송 프로토콜 설계

  1. 파일 크기 전달: 파일 전송 전에 파일 크기를 먼저 전송하여 클라이언트가 수신 준비를 할 수 있도록 합니다.
  2. 연속적인 데이터 송수신: 데이터를 송신하고 수신하는 동안 오류를 감지하고 재전송 메커니즘을 적용합니다.
  3. 완료 확인: 전송 완료 후 송수신 측에서 확인 메시지를 주고받아 전송 상태를 명확히 합니다.

이 메커니즘을 통해 파일 데이터의 안정적이고 신속한 송수신이 가능합니다.

파일 분할 전송 기법


큰 파일을 전송할 때는 데이터를 일정 크기로 나누어 전송하는 분할 전송 기법이 필요합니다. 이를 통해 전송의 효율성과 안정성을 높일 수 있습니다.

분할 전송의 필요성

  • 메모리 제한: 한 번에 큰 데이터를 송수신하면 메모리 부족이 발생할 수 있습니다.
  • 전송 안정성: 작은 단위로 데이터를 전송하면 네트워크 오류 발생 시 재전송이 용이합니다.
  • 네트워크 부담 감소: 데이터를 나누어 전송하면 네트워크 병목 현상을 완화할 수 있습니다.

분할 전송 구현

  1. 파일 읽기와 분할
    데이터를 버퍼 크기만큼 읽어 반복적으로 전송합니다.
   void send_file_in_chunks(int socket, const char *file_path) {
       FILE *file = fopen(file_path, "rb");
       if (file == NULL) {
           perror("File open failed");
           return;
       }

       char buffer[4096]; // 4KB 버퍼
       size_t bytes_read;

       while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
           if (send(socket, buffer, bytes_read, 0) == -1) {
               perror("Chunk send failed");
               break;
           }
       }

       fclose(file);
       printf("File sent in chunks successfully.\n");
   }
  1. 데이터 수신과 조립
    수신 측에서는 데이터를 버퍼에 저장하고, 이를 파일에 순차적으로 기록합니다.
   void receive_file_in_chunks(int socket, const char *output_path) {
       FILE *file = fopen(output_path, "wb");
       if (file == NULL) {
           perror("File open failed");
           return;
       }

       char buffer[4096]; // 4KB 버퍼
       ssize_t bytes_received;

       while ((bytes_received = recv(socket, buffer, sizeof(buffer), 0)) > 0) {
           fwrite(buffer, 1, bytes_received, file);
       }

       if (bytes_received == -1) {
           perror("Chunk receive failed");
       } else {
           printf("File received in chunks successfully.\n");
       }

       fclose(file);
   }

파일 크기 정보 송수신


분할 전송 시 파일 크기를 먼저 전송하여 수신 측에서 정확한 데이터 조립이 가능하도록 합니다.

// 파일 크기 전송
void send_file_size(int socket, long file_size) {
    send(socket, &file_size, sizeof(file_size), 0);
}

// 파일 크기 수신
long receive_file_size(int socket) {
    long file_size;
    recv(socket, &file_size, sizeof(file_size), 0);
    return file_size;
}

전송 종료 신호


전송이 끝났음을 나타내기 위해 EOF나 특정 신호를 활용합니다.

// 전송 종료 신호 보내기
send(socket, "EOF", 3, 0);

결론


분할 전송 기법을 사용하면 메모리 효율을 높이고 대용량 파일 전송의 안정성을 확보할 수 있습니다. 이를 통해 전송 속도와 신뢰성을 동시에 달성할 수 있습니다.

전송 중 오류 처리


네트워크 파일 전송 과정에서는 다양한 오류가 발생할 수 있습니다. 이러한 오류를 효과적으로 감지하고 처리하는 방법을 구현하면 프로그램의 신뢰성과 안정성을 높일 수 있습니다.

오류의 주요 유형

  1. 네트워크 중단: 연결이 갑작스럽게 끊어져 데이터 전송이 중단됩니다.
  2. 패킷 손실: 전송 중 일부 데이터 패킷이 손실될 수 있습니다.
  3. 버퍼 오버플로우: 잘못된 버퍼 크기 관리로 데이터 손실이 발생합니다.
  4. 파일 읽기/쓰기 오류: 파일이 존재하지 않거나 읽기/쓰기 권한이 없는 경우 발생합니다.

오류 처리 방법

  1. 네트워크 연결 확인
  • 소켓 함수 호출 결과를 확인하여 연결 상태를 점검합니다.
  • 예제: send()나 recv() 반환값이 -1일 경우 오류로 처리합니다.
   ssize_t result = send(socket, buffer, length, 0);
   if (result == -1) {
       perror("Send error");
       // 재시도 또는 연결 종료 처리
   }
  1. 재전송 메커니즘
  • 패킷 손실이 발생하면 특정 데이터를 재전송하도록 설계합니다.
  • ACK(확인 응답)를 활용하여 송수신 성공 여부를 확인합니다.
   int send_with_ack(int socket, const char *data, size_t length) {
       if (send(socket, data, length, 0) == -1) {
           perror("Send failed");
           return -1;
       }
       char ack[4];
       if (recv(socket, ack, sizeof(ack), 0) == -1) {
           perror("ACK receive failed");
           return -1;
       }
       if (strcmp(ack, "OK") != 0) {
           fprintf(stderr, "ACK not received\n");
           return -1;
       }
       return 0;
   }
  1. 타임아웃 설정
  • 데이터 수신이나 연결 시 타임아웃을 설정하여 무한 대기를 방지합니다.
   struct timeval timeout;
   timeout.tv_sec = 5;  // 5초 타임아웃
   timeout.tv_usec = 0;
   setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
  1. 파일 상태 점검
  • 파일이 존재하는지, 권한이 올바른지 확인합니다.
   FILE *file = fopen(file_path, "rb");
   if (file == NULL) {
       perror("File open error");
       return;
   }

전송 실패 처리


전송 실패 시 적절한 메시지를 출력하거나, 재시도 횟수를 제한하여 프로그램이 멈추지 않도록 설계합니다.

int retry_send(int socket, const char *data, size_t length, int retries) {
    int attempts = 0;
    while (attempts < retries) {
        if (send(socket, data, length, 0) != -1) {
            return 0; // 전송 성공
        }
        perror("Retry send error");
        attempts++;
    }
    return -1; // 재시도 실패
}

로그 기록


오류 발생 시 로그를 기록하여 디버깅 및 문제 원인 파악에 활용합니다.

void log_error(const char *error_message) {
    FILE *log_file = fopen("error.log", "a");
    if (log_file) {
        fprintf(log_file, "Error: %s\n", error_message);
        fclose(log_file);
    }
}

결론


전송 중 오류를 예상하고 적절히 처리하는 시스템은 네트워크 기반 프로그램의 신뢰성을 보장합니다. 재전송 메커니즘, 타임아웃 설정, 파일 상태 확인 등을 활용하여 안정적인 파일 전송을 구현할 수 있습니다.

클라이언트-서버 모델 구현 예시


파일 전송 프로그램에서 클라이언트-서버 모델은 데이터 송수신의 기본 구조를 제공합니다. 아래 예시는 TCP를 사용하여 서버와 클라이언트 간 파일 전송을 구현하는 코드입니다.

서버 코드


서버는 소켓을 생성하고 클라이언트의 요청을 수락하며, 파일 데이터를 전송합니다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

void send_file(int client_socket, const char *file_path) {
    FILE *file = fopen(file_path, "rb");
    if (file == NULL) {
        perror("File open failed");
        close(client_socket);
        return;
    }

    char buffer[1024];
    size_t bytes_read;

    while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
        if (send(client_socket, buffer, bytes_read, 0) == -1) {
            perror("Send failed");
            break;
        }
    }

    fclose(file);
    close(client_socket);
    printf("File sent successfully.\n");
}

int main() {
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("Socket creation failed");
        exit(1);
    }

    struct sockaddr_in server_addr = {0};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("Bind failed");
        close(server_socket);
        exit(1);
    }

    if (listen(server_socket, 1) == -1) {
        perror("Listen failed");
        close(server_socket);
        exit(1);
    }

    printf("Server is listening on port 8080...\n");

    int client_socket = accept(server_socket, NULL, NULL);
    if (client_socket == -1) {
        perror("Accept failed");
        close(server_socket);
        exit(1);
    }

    send_file(client_socket, "example.txt");
    close(server_socket);

    return 0;
}

클라이언트 코드


클라이언트는 서버에 연결을 요청하고, 파일 데이터를 수신하여 로컬 파일로 저장합니다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

void receive_file(int server_socket, const char *output_path) {
    FILE *file = fopen(output_path, "wb");
    if (file == NULL) {
        perror("File open failed");
        close(server_socket);
        return;
    }

    char buffer[1024];
    ssize_t bytes_received;

    while ((bytes_received = recv(server_socket, buffer, sizeof(buffer), 0)) > 0) {
        fwrite(buffer, 1, bytes_received, file);
    }

    if (bytes_received == -1) {
        perror("Receive failed");
    } else {
        printf("File received successfully.\n");
    }

    fclose(file);
    close(server_socket);
}

int main() {
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        perror("Socket creation failed");
        exit(1);
    }

    struct sockaddr_in server_addr = {0};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);

    if (connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("Connect failed");
        close(client_socket);
        exit(1);
    }

    receive_file(client_socket, "received_example.txt");
    return 0;
}

결론


이 예제에서는 간단한 클라이언트-서버 모델을 통해 텍스트 파일을 전송하는 과정을 보여줍니다. 이 코드를 바탕으로 대용량 파일 전송, 다중 클라이언트 지원 등 추가 기능을 구현할 수 있습니다.

테스트 및 디버깅


파일 전송 프로그램의 품질을 보장하려면 철저한 테스트와 디버깅이 필요합니다. 테스트는 프로그램의 모든 단계에서 발생할 수 있는 오류를 탐지하고, 디버깅은 이를 해결하여 안정적인 실행을 보장합니다.

테스트 계획

  1. 기본 기능 테스트
  • 소규모 텍스트 파일을 전송하여 전송 및 수신이 올바르게 이루어지는지 확인합니다.
  • 파일의 무결성을 검사합니다(예: MD5 해시 비교).
  1. 대용량 파일 테스트
  • 1GB 이상의 파일 전송을 테스트하여 메모리 누수나 속도 저하가 발생하지 않는지 확인합니다.
  • 파일 분할 전송 기능의 안정성을 점검합니다.
  1. 네트워크 환경 테스트
  • 다양한 네트워크 조건(높은 지연 시간, 낮은 대역폭, 패킷 손실 등)에서 프로그램을 실행해 봅니다.
  • 네트워크 중단 상황에서의 복구 기능을 확인합니다.
  1. 다중 클라이언트 테스트
  • 여러 클라이언트가 동시에 서버에 연결하여 파일을 전송 및 수신하는 시나리오를 테스트합니다.
  • 서버의 동시 처리 능력을 확인합니다.

디버깅 팁

  1. 로그 기록
  • 각 단계에서 발생한 이벤트를 로그로 기록하여 오류의 원인을 추적합니다.
   void log_event(const char *message) {
       FILE *log_file = fopen("program.log", "a");
       if (log_file) {
           fprintf(log_file, "%s\n", message);
           fclose(log_file);
       }
   }
  1. 네트워크 트래픽 분석
  • tcpdump 또는 Wireshark와 같은 네트워크 분석 도구를 사용하여 패킷 송수신 상태를 모니터링합니다.
  • 전송 실패 시 정확한 위치를 파악합니다.
  1. 메모리 누수 검사
  • valgrind와 같은 도구를 사용하여 메모리 누수를 탐지합니다.
   valgrind --leak-check=full ./server_program
  1. 단위 테스트 작성
  • 파일 전송 기능, 오류 처리 로직 등 주요 모듈에 대해 단위 테스트를 작성합니다.
  • 예제:
   void test_file_integrity() {
       const char *original_file = "example.txt";
       const char *received_file = "received_example.txt";
       if (compare_files(original_file, received_file)) {
           printf("Test passed: Files are identical.\n");
       } else {
           printf("Test failed: Files differ.\n");
       }
   }
  1. 에러 핸들링 확인
  • 모든 소켓 함수 호출에 대해 오류 처리가 제대로 이루어졌는지 점검합니다.
   int result = recv(socket, buffer, sizeof(buffer), 0);
   if (result == -1) {
       perror("Receive error");
   }

결과 분석 및 최적화

  1. 전송 속도 분석
  • 파일 전송 시간이 과도하게 길다면, 버퍼 크기나 네트워크 설정을 조정합니다.
  • 전송 속도를 출력하여 병목 현상을 확인합니다.
   printf("File transfer completed in %.2f seconds.\n", elapsed_time);
  1. 리소스 사용 모니터링
  • CPU와 메모리 사용량을 측정하여 프로그램이 과도한 리소스를 사용하지 않는지 확인합니다.

결론


테스트와 디버깅은 프로그램의 안정성을 보장하기 위한 필수 과정입니다. 철저한 테스트 계획과 디버깅 도구를 활용하여 프로그램을 개선하고, 다양한 환경에서 예외 없이 동작할 수 있도록 만드십시오.

요약


C 언어를 활용한 소켓 기반 파일 전송 프로그램 구현에 대해 다뤘습니다. 소켓 프로그래밍의 기본 개념에서 시작해, TCP를 활용한 파일 송수신 메커니즘, 대용량 파일 전송을 위한 분할 기법, 오류 처리, 그리고 클라이언트-서버 모델 구현 예제까지 단계적으로 설명했습니다. 또한 테스트와 디버깅 방법을 통해 프로그램의 안정성과 성능을 보장할 수 있는 방안을 제시했습니다. 이를 바탕으로 네트워크 파일 전송 응용 프로그램을 효율적으로 설계할 수 있습니다.

C 언어
C언어 소켓 프로그래밍 파일 전송
목차
  1. 소켓 프로그래밍의 기본 개념
    1. 소켓의 정의
    2. 소켓의 동작 원리
    3. 주요 함수
  2. TCP와 UDP의 차이
    1. TCP(Transmission Control Protocol)
    2. UDP(User Datagram Protocol)
    3. 파일 전송에 적합한 프로토콜
  3. 파일 전송을 위한 소켓 초기화
    1. 서버에서의 소켓 초기화
    2. 클라이언트에서의 소켓 초기화
    3. 결론
  4. 데이터 송수신 메커니즘
    1. 데이터 송신
    2. 데이터 수신
    3. 송수신의 핵심 함수
    4. 버퍼 관리와 전송 종료
    5. 전송 프로토콜 설계
  5. 파일 분할 전송 기법
    1. 분할 전송의 필요성
    2. 분할 전송 구현
    3. 파일 크기 정보 송수신
    4. 전송 종료 신호
    5. 결론
  6. 전송 중 오류 처리
    1. 오류의 주요 유형
    2. 오류 처리 방법
    3. 전송 실패 처리
    4. 로그 기록
    5. 결론
  7. 클라이언트-서버 모델 구현 예시
    1. 서버 코드
    2. 클라이언트 코드
    3. 결론
  8. 테스트 및 디버깅
    1. 테스트 계획
    2. 디버깅 팁
    3. 결과 분석 및 최적화
    4. 결론
  9. 요약