C언어에서 네트워크 버퍼 관리와 데이터 송수신 최적화

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

#define BUFFER_SIZE 1024

char *initialize_buffer(size_t size) {
    char *buffer = (char *)malloc(size);
    if (buffer == NULL) {
        perror("Failed to allocate buffer");
        exit(EXIT_FAILURE);
    }
    memset(buffer, 0, size); // 버퍼 초기화
    return buffer;
}

void write_to_buffer(char *buffer, size_t buffer_size, const char *data) {
    if (strlen(data) >= buffer_size) {
        fprintf(stderr, "Data exceeds buffer size\n");
        return;
    }
    strncpy(buffer, data, buffer_size - 1); // 널 문자를 포함하기 위해 여유 공간 확보
}

void read_from_buffer(const char *buffer) {
    printf("Buffer content: %s\n", buffer);
}

void free_buffer(char *buffer) {
    free(buffer);
}

#include <sys/select.h>

void async_read(int socket_fd) {
    fd_set read_fds;
    struct timeval timeout;

    FD_ZERO(&read_fds);
    FD_SET(socket_fd, &read_fds);

    timeout.tv_sec = 5; // 5초 타임아웃
    timeout.tv_usec = 0;

    int result = select(socket_fd + 1, &read_fds, NULL, NULL, &timeout);
    if (result > 0) {
        // 데이터 읽기 처리
    } else if (result == 0) {
        printf("Timeout occurred\n");
    } else {
        perror("select error");
    }
}

   int adjust_buffer_size(int socket_fd, int new_size) {
       return setsockopt(socket_fd, SOL_SOCKET, SO_RCVBUF, &new_size, sizeof(new_size));
   }

   #define MIN_BUFFER_SIZE 1024
   #define MAX_BUFFER_SIZE 65536

   int find_optimal_buffer_size() {
       for (int size = MIN_BUFFER_SIZE; size <= MAX_BUFFER_SIZE; size *= 2) {
           // 성능 테스트를 실행
       }
       return optimal_size; // 최적의 크기 반환
   }

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

#define BUFFER_SIZE 1024

typedef struct {
    char data[BUFFER_SIZE];
    int head;
    int tail;
    int size;
} RingBuffer;

void initialize_ring_buffer(RingBuffer *buffer) {
    buffer->head = 0;
    buffer->tail = 0;
    buffer->size = 0;
}

int is_full(RingBuffer *buffer) {
    return buffer->size == BUFFER_SIZE;
}

int is_empty(RingBuffer *buffer) {
    return buffer->size == 0;
}

void write_ring_buffer(RingBuffer *buffer, char value) {
    if (is_full(buffer)) {
        printf("Buffer overflow\n");
        return;
    }
    buffer->data[buffer->head] = value;
    buffer->head = (buffer->head + 1) % BUFFER_SIZE;
    buffer->size++;
}

char read_ring_buffer(RingBuffer *buffer) {
    if (is_empty(buffer)) {
        printf("Buffer underflow\n");
        return -1;
    }
    char value = buffer->data[buffer->tail];
    buffer->tail = (buffer->tail + 1) % BUFFER_SIZE;
    buffer->size--;
    return value;
}

   char *allocate_buffer(size_t size) {
       char *buffer = (char *)malloc(size);
       if (!buffer) {
           perror("Memory allocation failed");
           exit(EXIT_FAILURE);
       }
       return buffer;
   }

   #define POOL_SIZE 10
   char memory_pool[POOL_SIZE][BUFFER_SIZE];
   int pool_usage[POOL_SIZE] = {0};

   char *get_from_pool() {
       for (int i = 0; i < POOL_SIZE; i++) {
           if (!pool_usage[i]) {
               pool_usage[i] = 1;
               return memory_pool[i];
           }
       }
       return NULL; // 풀에 사용 가능한 메모리가 없음
   }

   void return_to_pool(char *buffer) {
       for (int i = 0; i < POOL_SIZE; i++) {
           if (memory_pool[i] == buffer) {
               pool_usage[i] = 0;
               break;
           }
       }
   }

   void process_data(char *source, char *destination, size_t size) {
       memcpy(destination, source, size);
   }

   void stack_memory_example() {
       char buffer[256]; // 스택에 버퍼 생성
       snprintf(buffer, sizeof(buffer), "Temporary data");
       printf("%s\n", buffer);
   }

   ssize_t send_data(int socket_fd, const char *data, size_t length) {
       ssize_t bytes_sent = send(socket_fd, data, length, 0);
       if (bytes_sent == -1) {
           perror("Send error");
           return -1;
       }
       return bytes_sent;
   }

   ssize_t receive_data(int socket_fd, char *buffer, size_t length) {
       ssize_t bytes_received = recv(socket_fd, buffer, length, 0);
       if (bytes_received == -1) {
           perror("Receive error");
           return -1;
       }
       return bytes_received;
   }

   #include <sys/socket.h>
   #include <netinet/tcp.h>

   void set_socket_timeout(int socket_fd, int timeout_sec) {
       struct timeval timeout;
       timeout.tv_sec = timeout_sec;
       timeout.tv_usec = 0;
       setsockopt(socket_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
       setsockopt(socket_fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
   }

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

   int retry_send(int socket_fd, const char *data, size_t length, int retries) {
       for (int i = 0; i < retries; i++) {
           if (send_data(socket_fd, data, length) != -1) {
               return 0;
           }
           printf("Retrying... (%d/%d)\n", i + 1, retries);
       }
       return -1;
   }

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

#define PORT 8080
#define BUFFER_SIZE 1024

void run_server() {
    int server_fd, client_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};

    // 소켓 생성
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("Socket failed");
        exit(EXIT_FAILURE);
    }

    // 주소 설정
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 바인딩
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("Bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 대기
    if (listen(server_fd, 3) < 0) {
        perror("Listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d...\n", PORT);

    // 클라이언트 연결 수락
    if ((client_fd = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
        perror("Accept failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 데이터 수신
    int bytes_read = read(client_fd, buffer, BUFFER_SIZE);
    printf("Received: %s\n", buffer);

    // 응답 전송
    const char *response = "Message received!";
    send(client_fd, response, strlen(response), 0);

    // 소켓 종료
    close(client_fd);
    close(server_fd);
}

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

#define PORT 8080
#define BUFFER_SIZE 1024

void run_client() {
    int socket_fd;
    struct sockaddr_in address;
    char buffer[BUFFER_SIZE] = {0};
    const char *message = "Hello, Server!";

    // 소켓 생성
    if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 서버 주소 설정
    address.sin_family = AF_INET;
    address.sin_port = htons(PORT);

    if (inet_pton(AF_INET, "127.0.0.1", &address.sin_addr) <= 0) {
        perror("Invalid address");
        close(socket_fd);
        exit(EXIT_FAILURE);
    }

    // 서버에 연결
    if (connect(socket_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("Connection failed");
        close(socket_fd);
        exit(EXIT_FAILURE);
    }

    // 데이터 전송
    send(socket_fd, message, strlen(message), 0);
    printf("Sent: %s\n", message);

    // 응답 수신
    int bytes_read = read(socket_fd, buffer, BUFFER_SIZE);
    printf("Server response: %s\n", buffer);

    // 소켓 종료
    close(socket_fd);
}

   ./server

   ./client