소켓 시작하기
C 기초

/* C17 보충 실습: 바이트 해석, 구조체, 비트 연산, 메모리 수명. */
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_PAYLOAD 1024U

typedef struct {
    uint8_t flags;
    uint16_t length;
} MessageHeader;

/* 학습용 형식: [flags 1바이트][길이 2바이트, big-endian][본문].
 * 실제 TCP/IP 헤더가 아니다. 구조체로 캐스팅하지 않고 값을 조립한다. */
static bool decode_header(const unsigned char *data, size_t size,
                          MessageHeader *out)
{
    if (data == NULL || out == NULL || size < 3) {
        return false;
    }

    out->flags = data[0];
    out->length = (uint16_t)(((unsigned int)data[1] << 8) | data[2]);
    return true;
}

static bool process_message(const unsigned char *data, size_t size)
{
    MessageHeader header;
    if (!decode_header(data, size, &header)) {
        puts("Rejected: incomplete header");
        return false;
    }

    /* 길이 검증을 먼저 하므로 size - 3이 음수처럼 언더플로하지 않는다.
     * 이 예제는 정확히 한 메시지가 들어 있는 배열을 처리한다. */
    if (header.length == 0 || header.length > MAX_PAYLOAD ||
        (size_t)header.length != size - 3) {
        puts("Rejected: invalid payload length");
        return false;
    }

    /* 할당 책임과 해제 책임을 이 함수가 함께 갖는다. */
    unsigned char *payload = malloc(header.length);
    if (payload == NULL) {
        fputs("Allocation failed\n", stderr);
        return false;
    }

    memcpy(payload, data + 3, header.length);
    printf("flags=0x%02X, length=%u\n",
           (unsigned int)header.flags, (unsigned int)header.length);
    printf("payload:");
    for (size_t i = 0; i < header.length; i++) {
        printf(" %02X", (unsigned int)payload[i]);
    }
    putchar('\n');

    /* 본문에 NUL이 있어도 길이로 처리한다. 문자열 함수는 쓰지 않는다. */
    free(payload);
    return true;
}

int main(void)
{
    const unsigned char message[] = {0x12, 0x00, 0x03, 0x41, 0x00, 0x42};
    if (!process_message(message, sizeof message)) {
        return EXIT_FAILURE;
    }

    /* 버퍼가 짧거나 헤더가 과도한 길이를 요구하면 거부하는지 확인한다. */
    const unsigned char too_large[] = {0x12, 0x04, 0x01};
    if (process_message(message, 2) ||
        process_message(message, sizeof message - 1) ||
        process_message(too_large, sizeof too_large)) {
        return EXIT_FAILURE;
    }

    /* TCP의 SYN/ACK 마스크를 수치로 관찰하는 별도 예시다.
     * 앞의 학습용 메시지나 실제 소켓 상태를 변경하지 않는다. */
    unsigned int flags = 0x12U;
    printf("SYN=%d, ACK=%d\n", (flags & 0x02U) != 0U,
           (flags & 0x10U) != 0U);
    flags |= 0x01U;
    flags &= ~0x02U;
    printf("after set FIN / clear SYN: 0x%02X\n", flags);

    const unsigned int version_ihl = 0x45U;
    printf("IPv4 version=%u, header bytes=%u\n",
           version_ihl >> 4, (version_ihl & 0x0FU) * 4U);
    return EXIT_SUCCESS;
}

/* C17 보충 실습: 실제 소켓 대신 가상의 fd 숫자를 저장한다. */
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct ClientNode {
    int socket_fd;
    struct ClientNode *next;
} ClientNode;

static bool add_client(ClientNode **head, int fd)
{
    ClientNode *node = malloc(sizeof *node);
    if (node == NULL) {
        return false;
    }

    node->socket_fd = fd;
    node->next = *head;
    *head = node;
    return true;
}

static bool remove_client(ClientNode **head, int fd)
{
    /* link는 현재 노드를 가리키는 연결 자체의 주소다.
     * 첫 노드에서는 head, 이후에는 앞 노드의 next를 가리킨다. */
    ClientNode **link = head;
    while (*link != NULL) {
        ClientNode *node = *link;
        if (node->socket_fd == fd) {
            *link = node->next;
            free(node);
            return true;
        }
        link = &node->next;
    }
    return false;
}

static void clear_clients(ClientNode **head)
{
    while (*head != NULL) {
        ClientNode *node = *head;
        *head = node->next;
        free(node);
    }
}

static void print_clients(const ClientNode *head)
{
    printf("head");
    for (const ClientNode *node = head; node != NULL; node = node->next) {
        printf(" -> %d", node->socket_fd);
    }
    puts(" -> NULL");
}

int main(void)
{
    ClientNode *head = NULL;
    if (!add_client(&head, 4) || !add_client(&head, 7)) {
        fputs("Allocation failed\n", stderr);
        clear_clients(&head);
        return EXIT_FAILURE;
    }

    print_clients(head);
    printf("remove 4: %s\n", remove_client(&head, 4) ? "OK" : "missing");
    print_clients(head);
    printf("remove 99: %s\n", remove_client(&head, 99) ? "OK" : "missing");

    clear_clients(&head);
    print_clients(head);
    return EXIT_SUCCESS;
}

/* C17 보충 실습: 성공 여부와 데이터 값을 분리한 LIFO 스택. */
#include <stdbool.h>
#include <stdio.h>

#define CAPACITY 3

typedef struct {
    int values[CAPACITY];
    size_t count;
} Stack;

static bool push(Stack *stack, int value)
{
    if (stack->count == CAPACITY) {
        return false;
    }

    stack->values[stack->count] = value;
    stack->count++;
    return true;
}

static bool pop(Stack *stack, int *out)
{
    if (stack->count == 0) {
        return false;
    }

    stack->count--;
    *out = stack->values[stack->count];
    return true;
}

int main(void)
{
    Stack stack = {0};
    const int values[] = {10, 20, -1, 40};
    for (size_t i = 0; i < sizeof values / sizeof values[0]; i++) {
        printf("push %d: %s\n", values[i],
               push(&stack, values[i]) ? "OK" : "FULL");
    }

    /* -1도 정상 데이터다. 빈 스택은 false 반환으로 구분한다. */
    int value;
    while (pop(&stack, &value)) {
        printf("pop: %d\n", value);
    }
    printf("pop again: %s\n", pop(&stack, &value) ? "OK" : "EMPTY");
    return 0;
}

/* C17 보충 실습: 앞의 빈 공간을 재사용하지 않는 선형 큐의 한계. */
#include <stdbool.h>
#include <stdio.h>

#define CAPACITY 5

typedef struct {
    int values[CAPACITY];
    size_t front;
    size_t rear;
} Queue;

static bool enqueue(Queue *queue, int value)
{
    if (queue->rear == CAPACITY) {
        return false;
    }

    queue->values[queue->rear] = value;
    queue->rear++;
    return true;
}

static bool dequeue(Queue *queue, int *out)
{
    if (queue->front == queue->rear) {
        return false;
    }

    *out = queue->values[queue->front];
    queue->front++;
    return true;
}

int main(void)
{
    Queue queue = {0};
    for (int value = 1001; value <= 1005; value++) {
        printf("enqueue %d: %s\n", value,
               enqueue(&queue, value) ? "OK" : "FULL");
    }

    int value;
    for (int i = 0; i < 3; i++) {
        if (dequeue(&queue, &value)) {
            printf("dequeue: %d\n", value);
        }
    }

    /* 앞의 세 칸이 비었어도 rear == CAPACITY이므로 삽입이 실패한다. */
    printf("front=%zu, rear=%zu, waiting=%zu\n",
           queue.front, queue.rear, queue.rear - queue.front);
    printf("enqueue 1006: %s\n", enqueue(&queue, 1006) ? "OK" : "FULL");
    while (dequeue(&queue, &value)) {
        printf("dequeue: %d\n", value);
    }
    printf("dequeue again: %s\n", dequeue(&queue, &value) ? "OK" : "EMPTY");
    return 0;
}

/* C17 보충 실습: 5칸 중 한 칸을 비워 최대 4개를 저장한다. */
#include <stdbool.h>
#include <stdio.h>

#define SIZE 5

typedef struct {
    int values[SIZE];
    size_t front;
    size_t rear;
} RingQueue;

static bool enqueue(RingQueue *queue, int value)
{
    size_t next = (queue->rear + 1) % SIZE;
    if (next == queue->front) {
        return false;
    }

    queue->values[queue->rear] = value;
    queue->rear = next;
    return true;
}

static bool dequeue(RingQueue *queue, int *out)
{
    if (queue->front == queue->rear) {
        return false;
    }

    *out = queue->values[queue->front];
    queue->front = (queue->front + 1) % SIZE;
    return true;
}

static void print_queue(const RingQueue *queue)
{
    printf("front=%zu, rear=%zu |", queue->front, queue->rear);
    for (size_t i = queue->front; i != queue->rear; i = (i + 1) % SIZE) {
        printf(" %d", queue->values[i]);
    }
    putchar('\n');
}

int main(void)
{
    RingQueue queue = {0};
    for (int value = 10; value <= 50; value += 10) {
        printf("enqueue %d: %s\n", value,
               enqueue(&queue, value) ? "OK" : "FULL");
    }
    print_queue(&queue);

    int value;
    for (int i = 0; i < 2; i++) {
        if (dequeue(&queue, &value)) {
            printf("dequeue: %d\n", value);
        }
    }

    /* 50은 인덱스 4, 60은 인덱스 0에 저장된다. */
    printf("enqueue 50: %s\n", enqueue(&queue, 50) ? "OK" : "FULL");
    printf("enqueue 60: %s\n", enqueue(&queue, 60) ? "OK" : "FULL");
    print_queue(&queue);

    while (dequeue(&queue, &value)) {
        printf("dequeue: %d\n", value);
    }
    printf("dequeue again: %s\n", dequeue(&queue, &value) ? "OK" : "EMPTY");
    return 0;
}

/* C17 보충 실습: 원본의 포트 기반 체이닝 해시 테이블.
 * fd는 가상 숫자다. 실제 연결 식별에는 주소 등 추가 정보가 필요하다. */
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define TABLE_SIZE 100

typedef struct Bucket {
    uint16_t port;
    int socket_fd;
    struct Bucket *next;
} Bucket;

static Bucket *table[TABLE_SIZE] = {0};

static size_t hash(uint16_t port)
{
    return port % TABLE_SIZE;
}

static bool insert(uint16_t port, int fd)
{
    size_t index = hash(port);
    for (Bucket *node = table[index]; node != NULL; node = node->next) {
        if (node->port == port) {
            node->socket_fd = fd;
            return true;
        }
    }

    Bucket *node = malloc(sizeof *node);
    if (node == NULL) {
        return false;
    }

    node->port = port;
    node->socket_fd = fd;
    node->next = table[index];
    table[index] = node;
    return true;
}

static bool search(uint16_t port, int *out)
{
    for (const Bucket *node = table[hash(port)]; node != NULL; node = node->next) {
        /* 해시 인덱스가 같아도 원래 키가 같은지 다시 비교한다. */
        if (node->port == port) {
            *out = node->socket_fd;
            return true;
        }
    }
    return false;
}

static bool remove_port(uint16_t port)
{
    Bucket **link = &table[hash(port)];
    while (*link != NULL) {
        Bucket *node = *link;
        if (node->port == port) {
            *link = node->next;
            free(node);
            return true;
        }
        link = &node->next;
    }
    return false;
}

static void free_table(void)
{
    for (size_t i = 0; i < TABLE_SIZE; i++) {
        while (table[i] != NULL) {
            Bucket *node = table[i];
            table[i] = node->next;
            free(node);
        }
    }
}

static void print_bucket(uint16_t port)
{
    printf("bucket[%zu]", hash(port));
    for (const Bucket *node = table[hash(port)]; node != NULL; node = node->next) {
        printf(" -> %u:%d", (unsigned int)node->port, node->socket_fd);
    }
    puts(" -> NULL");
}

int main(void)
{
    /* 80과 8080은 같은 버킷 80에 들어간다. */
    if (!insert(80, 10) || !insert(8080, 11) || !insert(443, 12)) {
        fputs("Allocation failed\n", stderr);
        free_table();
        return EXIT_FAILURE;
    }
    print_bucket(80);

    int fd;
    if (search(8080, &fd)) {
        printf("search 8080: %d\n", fd);
    }
    if (!insert(8080, 20)) {
        free_table();
        return EXIT_FAILURE;
    }
    if (search(8080, &fd)) {
        printf("updated 8080: %d\n", fd);
    }

    printf("remove 8080: %s\n", remove_port(8080) ? "OK" : "missing");
    print_bucket(80);
    printf("search 8080: %s\n", search(8080, &fd) ? "found" : "missing");
    printf("search 443: %s\n", search(443, &fd) ? "found" : "missing");

    free_table();
    return EXIT_SUCCESS;
}