C 언어로 TCP 서버와 클라이언트 구현하는 법

C 언어로 TCP 서버와 클라이언트를 구현하는 것은 네트워크 프로그래밍의 핵심 요소 중 하나입니다. TCP는 신뢰성 있는 데이터 전송을 보장하는 프로토콜로, 다양한 네트워크 애플리케이션에서 널리 사용됩니다. 이 기사에서는 TCP 프로토콜의 기초부터 C 언어로 TCP 서버와 클라이언트를 구현하는 방법, 그리고 이를 활용한 실전 사례까지 다루어 네트워크 프로그래밍을 이해하고 실습할 수 있는 기반을 제공합니다.

TCP 프로토콜이란 무엇인가
네트워크 소켓의 기초
TCP 서버 구현 단계
TCP 클라이언트 구현 단계
데이터 전송 및 수신
에러 처리 및 디버깅
동시 접속 클라이언트 처리
실전 응용 사례
요약

TCP 프로토콜이란 무엇인가

TCP(Transmission Control Protocol)는 인터넷에서 데이터를 신뢰성 있게 전송하기 위한 표준 프로토콜입니다. TCP는 데이터를 패킷으로 나누고, 이를 순차적으로 전송하며, 데이터가 올바르게 도착했는지 확인하는 역할을 합니다.

TCP의 주요 특징

연결 기반: 데이터 전송 전 송신자와 수신자 간에 연결이 설정됩니다.
신뢰성 보장: 데이터가 손실되거나 순서가 뒤바뀌는 경우 자동으로 재전송하고 순서를 복원합니다.
흐름 제어: 네트워크 혼잡을 방지하기 위해 데이터 전송 속도를 조절합니다.
양방향 통신: 양쪽이 동시에 데이터를 송수신할 수 있는 전이중 통신을 지원합니다.

TCP와 UDP의 차이

TCP와 유사한 프로토콜로 UDP(User Datagram Protocol)가 있습니다. 두 프로토콜의 주요 차이는 다음과 같습니다.

특징	TCP	UDP
연결 방식	연결 기반	비연결 기반
데이터 신뢰성	보장	보장하지 않음
속도	상대적으로 느림	빠름
용도	웹 브라우징, 이메일 전송	스트리밍, 게임

TCP의 활용

TCP는 웹 브라우징, 파일 전송, 이메일 등 신뢰성이 중요한 애플리케이션에서 주로 사용됩니다. 예를 들어, HTTP와 FTP는 모두 TCP를 기반으로 작동합니다.

TCP 프로토콜에 대한 이러한 기초 지식을 바탕으로, C 언어를 사용해 TCP 기반의 서버와 클라이언트를 구축하는 방법을 다음 항목에서 살펴보겠습니다.

네트워크 소켓의 기초

네트워크 소켓은 인터넷을 통해 데이터를 송수신하기 위해 사용하는 소프트웨어 인터페이스입니다. TCP와 같은 프로토콜이 데이터를 처리하기 위해 소켓을 기반으로 작동합니다.

소켓의 정의와 역할

소켓은 네트워크 상의 두 노드 간 통신의 끝점을 의미합니다. 예를 들어, 서버와 클라이언트 간 데이터를 주고받기 위해 소켓이 생성됩니다. TCP 소켓은 데이터를 스트림 형식으로 전달하며 신뢰성을 보장합니다.

소켓의 종류

스트림 소켓(SOCK_STREAM): TCP를 기반으로 하며 신뢰성 있고 연결 지향적인 통신을 제공합니다.
데이터그램 소켓(SOCK_DGRAM): UDP를 기반으로 하며 비연결형 통신으로 빠른 데이터 전송에 사용됩니다.

소켓 생성의 기본 구조

C 언어에서 소켓을 생성하고 사용하는 기본 흐름은 다음과 같습니다.

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

int main() {
    int socket_desc;
    struct sockaddr_in server;

    // 1. 소켓 생성
    socket_desc = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_desc == -1) {
        printf("소켓 생성 실패\n");
        return 1;
    }

    // 2. 서버 주소 설정
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    server.sin_family = AF_INET;
    server.sin_port = htons(8080);

    // 3. 서버 연결
    if (connect(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0) {
        printf("연결 실패\n");
        return 1;
    }
    printf("연결 성공\n");

    // 4. 소켓 닫기
    close(socket_desc);

    return 0;
}

소켓의 주요 함수

socket(): 새로운 소켓을 생성합니다.
bind(): 서버에서 소켓과 IP 주소 및 포트를 연결합니다.
listen(): 서버에서 클라이언트 요청을 대기합니다.
accept(): 클라이언트의 연결 요청을 수락합니다.
connect(): 클라이언트에서 서버에 연결 요청을 보냅니다.
send()/recv(): 데이터를 송수신합니다.
close(): 소켓을 닫습니다.

소켓의 중요성

소켓은 네트워크 프로그래밍의 기반이 되는 도구입니다. TCP 서버와 클라이언트를 구현하려면 소켓을 생성하고 관리하는 방법을 이해하는 것이 필수적입니다.

다음 항목에서는 TCP 서버 구현 과정을 구체적으로 설명합니다.

TCP 서버 구현 단계

C 언어로 TCP 서버를 구현하려면 소켓을 생성하고 클라이언트와의 연결을 처리하는 일련의 단계를 따라야 합니다. 아래는 TCP 서버의 주요 구현 단계와 예제 코드입니다.

TCP 서버의 구현 흐름

소켓 생성: 서버에서 사용할 소켓을 생성합니다.
소켓 바인딩: 생성한 소켓에 IP 주소와 포트를 연결합니다.
연결 대기: 클라이언트의 연결 요청을 대기합니다.
클라이언트 연결 수락: 클라이언트 요청을 수락하고 통신용 소켓을 생성합니다.
데이터 송수신: 클라이언트와 데이터를 주고받습니다.
소켓 닫기: 서버 소켓과 통신 소켓을 닫습니다.

TCP 서버의 예제 코드

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

int main() {
    int server_socket, client_socket, c;
    struct sockaddr_in server, client;
    char client_message[2000];

    // 1. 소켓 생성
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        printf("소켓 생성 실패\n");
        return 1;
    }
    printf("소켓 생성 성공\n");

    // 2. 서버 주소 설정
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;  // 모든 IP 주소에서 요청 수락
    server.sin_port = htons(8080);       // 포트 번호 설정

    // 3. 소켓 바인딩
    if (bind(server_socket, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("바인딩 실패");
        return 1;
    }
    printf("바인딩 성공\n");

    // 4. 연결 대기
    listen(server_socket, 3);
    printf("클라이언트 연결 대기 중...\n");

    // 5. 클라이언트 연결 수락
    c = sizeof(struct sockaddr_in);
    client_socket = accept(server_socket, (struct sockaddr *)&client, (socklen_t *)&c);
    if (client_socket < 0) {
        perror("클라이언트 연결 실패");
        return 1;
    }
    printf("클라이언트 연결 성공\n");

    // 6. 데이터 수신
    memset(client_message, 0, sizeof(client_message));
    if (recv(client_socket, client_message, sizeof(client_message), 0) > 0) {
        printf("클라이언트 메시지: %s\n", client_message);

        // 클라이언트에게 응답
        char *message = "서버에서 응답: 메시지 수신 완료\n";
        send(client_socket, message, strlen(message), 0);
    }

    // 7. 소켓 닫기
    close(client_socket);
    close(server_socket);

    return 0;
}

핵심 구현 포인트

IP 및 포트 설정: 서버는 클라이언트가 연결할 수 있도록 IP 주소와 포트를 명확히 정의해야 합니다.
비동기 처리: 여러 클라이언트 요청을 처리하려면 멀티스레딩 또는 비동기 I/O 방식을 사용합니다.
에러 처리: 각 단계에서 발생 가능한 에러를 철저히 처리하여 안정적인 서버를 만듭니다.

실행 결과

서버 실행 후 클라이언트가 연결을 요청하면 성공 메시지가 출력됩니다.
클라이언트가 보낸 메시지를 서버가 수신하고 응답을 반환합니다.

다음 항목에서는 TCP 클라이언트 구현 단계를 설명합니다.

TCP 클라이언트 구현 단계

C 언어로 TCP 클라이언트를 구현하려면 서버에 연결하고 데이터를 주고받는 과정을 따라야 합니다. 아래는 TCP 클라이언트의 주요 구현 단계와 예제 코드입니다.

TCP 클라이언트의 구현 흐름

소켓 생성: 클라이언트에서 서버와 통신할 소켓을 생성합니다.
서버 연결: 서버의 IP 주소와 포트를 지정하고 연결 요청을 보냅니다.
데이터 송수신: 서버와 데이터를 주고받습니다.
소켓 닫기: 클라이언트 소켓을 닫아 연결을 종료합니다.

TCP 클라이언트의 예제 코드

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

int main() {
    int socket_desc;
    struct sockaddr_in server;
    char message[1000], server_reply[2000];

    // 1. 소켓 생성
    socket_desc = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_desc == -1) {
        printf("소켓 생성 실패\n");
        return 1;
    }
    printf("소켓 생성 성공\n");

    // 2. 서버 주소 설정
    server.sin_addr.s_addr = inet_addr("127.0.0.1");  // 서버 IP 주소
    server.sin_family = AF_INET;
    server.sin_port = htons(8080);                   // 서버 포트 번호

    // 3. 서버 연결
    if (connect(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0) {
        printf("서버 연결 실패\n");
        return 1;
    }
    printf("서버 연결 성공\n");

    // 4. 데이터 전송
    printf("서버에 보낼 메시지 입력: ");
    fgets(message, sizeof(message), stdin);
    if (send(socket_desc, message, strlen(message), 0) < 0) {
        printf("데이터 전송 실패\n");
        return 1;
    }
    printf("메시지 전송 성공\n");

    // 5. 서버 응답 수신
    memset(server_reply, 0, sizeof(server_reply));
    if (recv(socket_desc, server_reply, sizeof(server_reply), 0) < 0) {
        printf("응답 수신 실패\n");
    } else {
        printf("서버 응답: %s\n", server_reply);
    }

    // 6. 소켓 닫기
    close(socket_desc);

    return 0;
}

핵심 구현 포인트

IP 및 포트 지정: 클라이언트는 연결할 서버의 IP 주소와 포트를 명확히 지정해야 합니다.
데이터 송수신 형식: 서버와 클라이언트가 동일한 데이터 형식을 사용하여 의사소통해야 합니다.
에러 처리: 연결 실패, 데이터 송수신 실패 등 에러를 감지하고 처리합니다.

실행 결과

클라이언트를 실행하면 서버에 연결 요청을 보냅니다.
연결 성공 후, 사용자가 입력한 메시지를 서버로 전송합니다.
서버의 응답을 수신하고 출력합니다.

응용 방안

TCP 클라이언트는 다양한 네트워크 애플리케이션에서 활용할 수 있습니다. 예를 들어, HTTP 요청을 생성하거나 파일 다운로드 클라이언트를 만드는 데 사용됩니다.

다음 항목에서는 서버와 클라이언트 간 데이터 전송과 수신 메커니즘에 대해 설명합니다.

데이터 전송 및 수신

TCP 서버와 클라이언트 간의 데이터 전송 및 수신은 네트워크 프로그래밍의 핵심입니다. 이 과정은 데이터를 효율적으로 송수신하고, 손실 없이 정확하게 처리하는 방법을 포함합니다.

TCP 데이터 전송의 기본 원리

스트림 기반 통신: TCP는 데이터를 스트림 형태로 전송합니다. 이는 데이터를 연속적인 바이트 흐름으로 처리한다는 의미입니다.
전송 신뢰성: TCP는 데이터가 목적지에 도달하지 않을 경우 재전송을 통해 전송의 신뢰성을 보장합니다.
양방향 통신: TCP 연결은 동시에 데이터를 송수신할 수 있는 전이중 통신을 지원합니다.

데이터 송수신을 위한 주요 함수

함수	설명	사용 예제
`send()`	데이터를 소켓을 통해 전송합니다.	`send(socket, buffer, size, flags);`
`recv()`	소켓에서 데이터를 수신합니다.	`recv(socket, buffer, size, flags);`
`write()`	데이터를 쓰기 위해 사용됩니다(유사한 동작).	`write(socket, buffer, size);`
`read()`	데이터를 읽기 위해 사용됩니다(유사한 동작).	`read(socket, buffer, size);`

TCP 서버와 클라이언트 데이터 송수신 예제

서버 측 코드 (데이터 송신):

char *response = "서버 메시지: 연결 성공!";
send(client_socket, response, strlen(response), 0);

클라이언트 측 코드 (데이터 수신):

char server_response[1024];
recv(socket_desc, server_response, sizeof(server_response), 0);
printf("서버 응답: %s\n", server_response);

데이터 송수신의 고려 사항

데이터 크기: 큰 데이터를 전송할 경우, 데이터를 패킷으로 나누어 처리해야 합니다.
버퍼 처리: 송수신 데이터를 저장하기 위한 버퍼를 적절한 크기로 설정해야 합니다.
동기 및 비동기 처리: 데이터 송수신은 동기 방식과 비동기 방식으로 구현할 수 있습니다.

버퍼 처리 예제

TCP는 전송된 데이터가 네트워크 속도에 따라 도달하기 때문에, 버퍼를 활용해 데이터를 분할하거나 재구성해야 할 수 있습니다.

// 클라이언트에서 큰 데이터 송신
char large_data[2048] = "여러 줄의 데이터 전송 예제입니다...";
int bytes_sent = send(socket_desc, large_data, strlen(large_data), 0);
printf("%d 바이트 전송 완료\n", bytes_sent);

에러 처리

데이터 송수신 과정에서 발생할 수 있는 에러를 대비해야 합니다.

연결 끊김: 송수신 도중 연결이 종료되면 복구하거나 종료 절차를 수행합니다.
버퍼 초과: 송수신 데이터가 버퍼 크기를 초과하면 손실이 발생할 수 있으므로 적절한 크기로 조정해야 합니다.

데이터 송수신의 활용

TCP를 통한 데이터 송수신은 다양한 네트워크 애플리케이션에서 활용됩니다. 예를 들어, 클라이언트에서 사용자 입력을 서버로 보내고, 서버에서 그 결과를 처리한 뒤 반환하는 구조를 쉽게 구현할 수 있습니다.

다음 항목에서는 TCP 통신 중 발생할 수 있는 에러 처리 및 디버깅 방법을 설명합니다.

에러 처리 및 디버깅

TCP 서버와 클라이언트 간 통신 중 발생하는 에러는 프로그램의 안정성을 저하시킬 수 있습니다. 적절한 에러 처리와 디버깅은 네트워크 프로그램의 신뢰성을 높이는 핵심 요소입니다.

TCP 통신 중 발생할 수 있는 주요 에러

소켓 생성 실패

원인: 시스템 자원 부족, 잘못된 파라미터 사용 등
해결: 오류 메시지를 출력하고 적절히 자원을 확보

소켓 바인딩 실패

원인: 이미 사용 중인 포트, 권한 부족 등
해결: 다른 포트 사용, 관리자 권한 실행

서버 연결 실패

원인: 서버 비활성 상태, 네트워크 문제
해결: 서버 상태 확인, 네트워크 연결 점검

데이터 송수신 실패

원인: 연결 끊김, 잘못된 버퍼 설정
해결: 연결 상태 확인, 버퍼 크기 조정

에러 처리 코드 예제

TCP 통신 중 발생할 수 있는 에러를 확인하고 적절히 처리하는 방법입니다.

소켓 생성 에러 처리:

int socket_desc = socket(AF_INET, SOCK_STREAM, 0);
if (socket_desc == -1) {
    perror("소켓 생성 실패");
    exit(EXIT_FAILURE);
}

서버 연결 에러 처리:

if (connect(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0) {
    perror("서버 연결 실패");
    close(socket_desc);
    exit(EXIT_FAILURE);
}

데이터 송수신 에러 처리:

int bytes_sent = send(socket_desc, message, strlen(message), 0);
if (bytes_sent < 0) {
    perror("데이터 전송 실패");
}
int bytes_received = recv(socket_desc, server_reply, sizeof(server_reply), 0);
if (bytes_received < 0) {
    perror("데이터 수신 실패");
}

디버깅을 위한 주요 도구와 기법

로그 출력

각 단계에서 로그를 출력하여 현재 상태를 확인합니다.

   printf("클라이언트 연결 요청...\n");

에러 코드 확인

errno를 사용하여 에러의 원인을 확인합니다.

   perror("에러 발생");

Wireshark

네트워크 패킷을 분석하여 통신 중 발생하는 문제를 식별합니다.

gdb

디버거를 사용해 코드의 실행 흐름을 분석하고 문제를 추적합니다.

예제: 소켓 연결 실패 디버깅

if (bind(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0) {
    perror("소켓 바인딩 실패");
    printf("확인 사항: 포트 사용 여부, 관리자 권한\n");
    exit(EXIT_FAILURE);
}

에러 예방을 위한 팁

타임아웃 설정: 연결 및 데이터 송수신에 타임아웃을 설정하여 무한 대기를 방지합니다.
포트 사용 확인: 사용 중인 포트를 방지하거나 적절히 해제합니다.
리소스 관리: 모든 소켓은 적절히 닫아 리소스 누수를 방지합니다.

에러 처리의 중요성

에러 처리는 네트워크 프로그램의 안정성을 보장하는 필수 요소입니다. 적절한 처리 방식을 통해 TCP 통신 중 발생하는 예외 상황에 대처할 수 있습니다.

다음 항목에서는 동시 접속 클라이언트를 처리하는 방법을 설명합니다.

동시 접속 클라이언트 처리

TCP 서버는 다수의 클라이언트로부터 동시 접속 요청을 처리해야 하는 경우가 많습니다. 이를 위해 멀티스레딩, 멀티프로세싱, 또는 비동기 I/O 방식을 사용할 수 있습니다.

동시 접속 처리 방식

멀티스레딩

각 클라이언트 연결에 대해 새로운 스레드를 생성하여 병렬로 처리합니다.
장점: 구현이 비교적 간단하며 클라이언트 처리 속도가 빠릅니다.
단점: 스레드 수가 많아지면 메모리 사용량이 증가하고 관리가 복잡해질 수 있습니다.

비동기 I/O

단일 스레드에서 비동기적으로 클라이언트 요청을 처리합니다.
장점: 높은 확장성을 제공하며 리소스 사용량이 적습니다.
단점: 구현이 복잡할 수 있습니다.

멀티프로세싱

각 클라이언트 연결에 대해 새로운 프로세스를 생성하여 처리합니다.
장점: 프로세스 간 충돌이 적어 안정적입니다.
단점: 프로세스 생성 및 전환 비용이 높아질 수 있습니다.

멀티스레딩을 활용한 동시 접속 처리 예제

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

void *handle_client(void *client_socket) {
    int sock = *(int *)client_socket;
    char client_message[2000];

    // 클라이언트로부터 메시지 수신
    memset(client_message, 0, sizeof(client_message));
    if (recv(sock, client_message, sizeof(client_message), 0) > 0) {
        printf("클라이언트 메시지: %s\n", client_message);

        // 클라이언트에 응답
        char *message = "서버에서 응답: 메시지 수신 완료\n";
        send(sock, message, strlen(message), 0);
    }

    close(sock); // 소켓 닫기
    free(client_socket); // 메모리 해제
    pthread_exit(NULL); // 스레드 종료
}

int main() {
    int server_socket, client_socket, c;
    struct sockaddr_in server, client;

    // 1. 서버 소켓 생성
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("소켓 생성 실패");
        return 1;
    }

    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(8080);

    // 2. 소켓 바인딩
    if (bind(server_socket, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("바인딩 실패");
        return 1;
    }

    listen(server_socket, 5);
    printf("클라이언트 연결 대기 중...\n");

    c = sizeof(struct sockaddr_in);
    while ((client_socket = accept(server_socket, (struct sockaddr *)&client, (socklen_t *)&c))) {
        printf("클라이언트 연결 성공\n");

        // 클라이언트를 처리할 스레드 생성
        pthread_t client_thread;
        int *new_sock = malloc(1);
        *new_sock = client_socket;
        if (pthread_create(&client_thread, NULL, handle_client, (void *)new_sock) < 0) {
            perror("스레드 생성 실패");
            return 1;
        }
        pthread_detach(client_thread); // 스레드 리소스 자동 해제
    }

    if (client_socket < 0) {
        perror("클라이언트 연결 실패");
        return 1;
    }

    close(server_socket);
    return 0;
}

구현의 주요 포인트

스레드 생성과 관리: pthread_create로 각 클라이언트를 처리하며, pthread_detach로 스레드 리소스를 자동 해제합니다.
메모리 관리: 동적으로 할당한 메모리는 적절히 해제해야 메모리 누수를 방지할 수 있습니다.
동기화: 여러 스레드가 공유 리소스를 사용하면 동기화 문제가 발생할 수 있으므로, 필요 시 pthread_mutex를 사용하여 동기화를 처리합니다.

고려 사항

스레드 개수 제한: 서버 자원을 초과하지 않도록 최대 스레드 개수를 제한합니다.
에러 처리: 클라이언트와의 통신 중 발생할 수 있는 모든 에러를 처리합니다.
성능 최적화: 멀티스레딩 대신 비동기 I/O 또는 이벤트 기반 방식을 사용하는 것도 고려할 수 있습니다.

다음 항목에서는 TCP 서버와 클라이언트를 활용한 실전 응용 사례를 다룹니다.

실전 응용 사례

TCP 서버와 클라이언트를 활용하면 네트워크 기반 애플리케이션을 손쉽게 구현할 수 있습니다. 아래는 TCP를 활용한 대표적인 응용 사례 두 가지입니다.

응용 사례 1: 간단한 채팅 프로그램

TCP 서버와 클라이언트를 사용하여 실시간 메시지를 주고받는 채팅 프로그램을 구현할 수 있습니다.

서버 코드 (요약):

클라이언트의 연결 요청을 수락합니다.
각 클라이언트의 메시지를 받아 다른 클라이언트로 전달합니다.
멀티스레딩을 통해 다수의 클라이언트를 동시에 처리합니다.

// 예제: 서버가 클라이언트의 메시지를 브로드캐스트
char buffer[1024];
recv(client_socket, buffer, sizeof(buffer), 0);
for (int i = 0; i < client_count; i++) {
    send(client_sockets[i], buffer, strlen(buffer), 0);
}

클라이언트 코드 (요약):

사용자 입력을 서버로 전송합니다.
서버로부터 다른 사용자의 메시지를 수신합니다.

// 예제: 사용자 입력 전송 및 메시지 수신
send(socket_desc, user_input, strlen(user_input), 0);
recv(socket_desc, buffer, sizeof(buffer), 0);
printf("받은 메시지: %s\n", buffer);

응용 사례 2: 파일 전송 프로그램

TCP 연결을 통해 서버와 클라이언트 간 파일을 업로드하거나 다운로드하는 프로그램을 구현할 수 있습니다.

서버 코드: 파일 수신

클라이언트로부터 파일 메타데이터(이름, 크기 등)를 수신합니다.
파일 내용을 수신하여 로컬 파일로 저장합니다.

FILE *fp = fopen("received_file.txt", "wb");
int bytes_read;
while ((bytes_read = recv(client_socket, buffer, sizeof(buffer), 0)) > 0) {
    fwrite(buffer, 1, bytes_read, fp);
}
fclose(fp);

클라이언트 코드: 파일 전송

전송할 파일의 메타데이터를 서버로 보냅니다.
파일 내용을 읽어 서버로 전송합니다.

FILE *fp = fopen("send_file.txt", "rb");
int bytes_read;
while ((bytes_read = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
    send(socket_desc, buffer, bytes_read, 0);
}
fclose(fp);

응용 사례의 주요 고려 사항

데이터 패킷 크기: 파일 전송 시 적절한 패킷 크기를 설정하여 효율적으로 데이터를 전송합니다.
에러 처리: 데이터 손실이나 연결 끊김 상황에 대비한 예외 처리를 구현합니다.
암호화: 민감한 데이터를 전송할 경우 암호화를 통해 보안을 강화합니다.

확장 가능성

채팅 프로그램: 메시지 기록 저장, 사용자 인증, GUI 추가
파일 전송 프로그램: 대용량 파일 분할 전송, 파일 다운로드 큐 구현

TCP 기반의 이 응용 사례를 통해 실제 네트워크 애플리케이션 개발의 기초를 이해할 수 있습니다.
다음 항목에서는 TCP 서버와 클라이언트 구현 내용을 요약합니다.

요약

이 기사에서는 C 언어로 TCP 서버와 클라이언트를 구현하는 방법을 단계별로 설명했습니다. TCP 프로토콜의 개념부터 네트워크 소켓 사용법, 서버와 클라이언트 구현, 동시 접속 클라이언트 처리, 그리고 실전 응용 사례까지 다뤘습니다.

TCP를 활용하면 채팅 프로그램이나 파일 전송 시스템과 같은 다양한 네트워크 애플리케이션을 구축할 수 있습니다. 이를 통해 신뢰성 있는 데이터 전송과 실용적인 네트워크 프로그래밍의 기초를 탄탄히 다질 수 있습니다.