[ubuntu] 소켓 통신 채팅 서버

📬 소켓 통신 이란??

아래 글에서 정리하였습니다.

https://toby12.tistory.com/52

[ubuntu] 소켓 통신 데이터 전송 및 저장

 

📬 실습 목표

1. 소켓 통신을 이용한 채팅 프로그램 작성

 

※ 채팅 서버 ※  

1. 서버 초기화 및 소켓 생성
   • 매개변수로 받은 포트 번호로 서버 초기화 및 소켓을 생성 
2. 클라이언트 연결 대기 및 인증
   • accept 함수를 사용하여 연결 요청받은 클라이언트의 연결 
   • 클라이언트가 연결되면, ID 및 비밀번호를 받아 인증 수행
3. 클라이언트 관리 및 쓰레드 생성
   • 최대 MAX_CLNT 개수까지의 클라이언트를 관리
   • 새로운 클라이언트가 연결되면, 쓰레드를 생성하여 해당 클라이언트와 통신을 담당
4. 메시지 전송
   • send_msg 함수를 통해 클라이언트에게 메시지를 전송
   • 'ALLMSG'라는 특별한 수신자에게는 모든 클라이언트에게 메시지를 전송
   • 'IDLIST' 수신자에게는 현재 서버에 연결된 모든 클라이언트의 ID 목록을 전송
5. 쓰레드 함수 (clnt_connection)
   • 클라이언트 쓰레드 함수로, 클라이언트와의 통신을 담당
   • 클라이언트로부터 메시지를 수신하고, 이를 처리하여 다른 클라이언트에게 전파

※ 클라이언트 ※  

1. 클라이언트 초기화 및 소켓 생성
   • 매개변수로 받은 서버의 IP 주소와 포트 번호로 서버에 소켓을 생성하여 연결을 시도
2. 인증
   • 매개변수에 지정한 이름으로 서버에 접속, 비밀번호를 함께 전송하여 인증을 수행함
3. 메시지 송수신
   • 사용자는 키보드로 메시지를 입력하고, 이를 서버에 전송
   • 서버로부터의 메시지는 별도의 쓰레드를 통해 수신되어 화면에 출력됨
4. 쓰레드 함수 (send_msg, recv_msg)
   • 각각 메시지 송신 및 수신을 담당하는 쓰레드 함수이다. 
   • send_msg 함수는 사용자의 입력을 읽어 서버로 전송하고
   • recv_msg 함수는 서버로부터의 메시지를 수신하여 화면에 출력험

※ 추가 내용 ※ 

• 쓰레드 사용
  • 각 클라이언트는 별도의 쓰레드에서 처리되고 이를 통해 여러 클라이언트와 동시에 통신할 수 있습니다.
  • pthread 라이브러리를 사용하여 멀티쓰레딩을 구현하였습니다.
• 뮤텍스 사용
  • 서버에서는 클라이언트의 연결 및 해제에 따른 공유 자원 접근을 보호하기 위해 뮤텍스를 사용
  • pthread_mutex_lock 및 pthread_mutex_unlock 함수를 사용하여 상호배제를 구현하였습니다.
• 클라이언트 관리
  • 서버에서는 최대 MAX_CLNT 개의 클라이언트를 관리
  • 클라이언트의 상태는 CLIENT_INFO 구조체를 통해 관리되며, 각 클라이언트는 ID, IP 주소, 소켓 식별자 등을
    가지고 있습니다.
• 메시지 전송
  • 서버에서는 특정 수신자에게 메시지를 전송하는 send_msg 함수를 구현
  • 수신자가 'ALLMSG'인 경우에는 모든 클라이언트에게 메시지를 전파하고, 'IDLIST'인 경우에는
    현재 접속 중인 클라이언트의 ID 목록을 전송합니다.

2. make 파일로 빌드

3. server, client 프로그램 실행   

4. 결과 확인

📬 실습 결과

소켓 통신을 이용한 채팅 프로그램 작성

1. client.c

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

#define BUF_SIZE 100
#define NAME_SIZE 20
#define ARR_CNT 5

char name[NAME_SIZE] = "[Default]";  // 클라이언트의 이름
char msg[BUF_SIZE];  // 메시지를 저장하는 버퍼

void *send_msg(void *arg);
void *recv_msg(void *arg);
void error_handling(char *msg);

int main(int argc, char *argv[]) {
    int sock;
    struct sockaddr_in serv_addr;
    pthread_t snd_thread, rcv_thread;
    void *thread_return;

    // 매개변수가 4개가 아닐 시 안내 및 종료(프로그램, IP, 포트, 클라이언트 이름)
    if (argc != 4) {
        printf("Usage : %s <IP> <port> <name>\n", argv[0]);
        exit(1);
    }
    // 클라이언트 이름 설정
    sprintf(name, "%s", argv[3]);
    
    // 소켓 생성
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if (sock == -1)
        error_handling("socket() error");

    // 서버 주소 설정
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));

    // 서버에 연결
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("connect() error");

    // 클라이언트의 이름과 "PASSWD"를 서버에 전송
    sprintf(msg, "[%s:PASSWD]", name);
    write(sock, msg, strlen(msg));

    // 쓰레드 생성 및 조인
    pthread_create(&rcv_thread, NULL, recv_msg, (void *)&sock);
    pthread_create(&snd_thread, NULL, send_msg, (void *)&sock);
    pthread_join(snd_thread, &thread_return);

    // 소켓 닫은 후 프로그램 종료
    close(sock);
    return 0;
}
// 메시지를 서버로 전송하는 함수
void *send_msg(void *arg) {
    int *sock = (int *)arg;
    int str_len;
    int ret;
    fd_set initset, newset;
    struct timeval tv;
    char name_msg[NAME_SIZE + BUF_SIZE + 2];

    // 파일 초기화
    FD_ZERO(&initset);
    FD_SET(STDIN_FILENO, &initset);

    // 메시지 입력 대기
    fputs("Input a message! [ID]msg (Default ID:ALLMSG)\n", stdout);
    while (1) {
        memset(msg, 0, sizeof(msg));
        name_msg[0] = '\0';
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        newset = initset;
        ret = select(STDIN_FILENO + 1, &newset, NULL, NULL, &tv);

        if (FD_ISSET(STDIN_FILENO, &newset)) {
            // 사용자로부터 메시지 입력 받음
            fgets(msg, BUF_SIZE, stdin);
            // "quit"을 입력하면 클라이언트 소켓을 종료
            if (!strncmp(msg, "quit\n", 5)) {
                *sock = -1;
                return NULL;
            } else if (msg[0] != '[') {
                // 메시지의 첫 글자가 '['이 아니면 "[ALLMSG]"를 추가하여 전송
                strcat(name_msg, "[ALLMSG]");
                strcat(name_msg, msg);
            } else
                strcpy(name_msg, msg);
            // 서버로 메시지 전송
            if (write(*sock, name_msg, strlen(name_msg)) <= 0) {
                *sock = -1;
                return NULL;
            }}
        if (ret == 0) {
            // 타임아웃 발생 시
            if (*sock == -1)
                return NULL;
        }}}
// 서버로부터 메시지를 수신하는 함수
void *recv_msg(void *arg) {
    int *sock = (int *)arg;
    int i;
    char *pToken;
    char *pArray[ARR_CNT] = {0};
    char name_msg[NAME_SIZE + BUF_SIZE + 1];
    int str_len;

    while (1) {
        memset(name_msg, 0x0, sizeof(name_msg));
        str_len = read(*sock, name_msg, NAME_SIZE + BUF_SIZE);

        if (str_len <= 0) {
            // 소켓이 닫힌 경우
            *sock = -1;
            return NULL;
        }
        name_msg[str_len] = 0;

        // 수신한 메시지를 표준 출력에 출력
        fputs(name_msg, stdout);

        // 메시지 파싱 
        /*
        pToken = strtok(name_msg, "[:]");
        i = 0;
        while (pToken != NULL) {
            pArray[i] = pToken;
            if (++i >= ARR_CNT)
                break;
            pToken = strtok(NULL, "[:]");
        }
        printf("id:%s, msg:%s\n", pArray[0], pArray[1]);
        */
    }}
// 에러 메시지 출력 후 프로그램을 종료하는 함수
void error_handling(char *msg) {
    fputs(msg, stderr);
    fputc('\n', stderr);
    exit(1);
}

 

2. server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/time.h>
#include <time.h>
#include <errno.h>

#define BUF_SIZE 100
#define MAX_CLNT 32
#define ID_SIZE 10
#define ARR_CNT 5
#define DEBUG

// 클라이언트로부터 받은 메시지 정보를 저장하는 구조체
typedef struct {
    char fd;
    char *from;
    char *to;
    char *msg;
    int len;
} MSG_INFO;
// 클라이언트 정보를 저장하는 구조체
typedef struct {
    int index;
    int fd;
    char ip[20];
    char id[ID_SIZE];
    char pw[ID_SIZE];
} CLIENT_INFO;

void *clnt_connection(void *arg);
void send_msg(MSG_INFO *msg_info, CLIENT_INFO *first_client_info);
void error_handling(char *msg);
void log_file(char *msgstr);

int clnt_cnt = 0;
pthread_mutex_t mutx;

int main(int argc, char *argv[]) {
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    int clnt_adr_sz;
    int sock_option = 1;
    pthread_t t_id[MAX_CLNT] = {0};
    int str_len = 0;
    int i;
    char idpasswd[(ID_SIZE * 2) + 3];
    char *pToken;
    char *pArray[ARR_CNT] = {0};
    char msg[BUF_SIZE];

    // 미리 등록된 클라이언트 정보
    CLIENT_INFO client_info[MAX_CLNT] = {{0, -1, "", "KHJ_LIN", "PASSWD"}, \
             {0,-1,"","KHJ_SQL","PASSWD"},  {0,-1,"","3","PASSWD"}, \
			 {0,-1,"","4","PASSWD"},  {0,-1,"","5","PASSWD"}, \
			 {0,-1,"","6","PASSWD"},  {0,-1,"","7","PASSWD"}, \
			 {0,-1,"","8","PASSWD"},  {0,-1,"","9","PASSWD"}, \
			 {0,-1,"","10","PASSWD"},  {0,-1,"","11","PASSWD"}, \
			 {0,-1,"","12","PASSWD"},  {0,-1,"","13","PASSWD"}, \
			 {0,-1,"","14","PASSWD"},  {0,-1,"","15","PASSWD"}, \
			 {0,-1,"","16","PASSWD"},  {0,-1,"","17","PASSWD"}, \
			 {0,-1,"","18","PASSWD"},  {0,-1,"","19","PASSWD"}, \
			 {0,-1,"","20","PASSWD"},  {0,-1,"","21","PASSWD"}, \
			 {0,-1,"","22","PASSWD"},  {0,-1,"","23","PASSWD"}, \
			 {0,-1,"","24","PASSWD"},  {0,-1,"","25","PASSWD"}, \
			 {0,-1,"","26","PASSWD"},  {0,-1,"","27","PASSWD"}, \
			 {0,-1,"","28","PASSWD"},  {0,-1,"","29","PASSWD"}, \
			 {0,-1,"","30","PASSWD"},  {0,-1,"","31","PASSWD"}, \
			 {0,-1,"","32","PASSWD"}};

    // 커맨드 라인에서 포트 번호를 입력받음
    if (argc != 2) {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
    fputs("IoT Server Start!!\n", stdout);

    // 뮤텍스 초기화
    if (pthread_mutex_init(&mutx, NULL))
        error_handling("mutex init error");

    // 소켓 생성
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    // 소켓 옵션 설정
    setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void *)&sock_option, sizeof(sock_option));

    // 소켓 바인딩
    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");

    // 소켓 리스닝
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    while (1) {
        clnt_adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
        if (clnt_cnt >= MAX_CLNT) {
            printf("socket full\n");
            shutdown(clnt_sock, SHUT_WR);
            continue;
        } else if (clnt_sock < 0) {
            perror("accept()");
            continue;
        }
        // 클라이언트로부터 ID와 비밀번호를 읽음
        str_len = read(clnt_sock, idpasswd, sizeof(idpasswd));
        idpasswd[str_len] = '\0';

        if (str_len > 0) {
            i = 0;
            pToken = strtok(idpasswd, "[:]");
            while (pToken != NULL) {
                pArray[i] = pToken;
                if (i++ >= ARR_CNT)
                    break;
                pToken = strtok(NULL, "[:]");
            }
            for (i = 0; i < MAX_CLNT; i++) {
                if (!strcmp(client_info[i].id, pArray[0])) {
                    if (client_info[i].fd != -1) {
                        // 이미 로그인된 ID인 경우
                        sprintf(msg, "[%s] Already logged!\n", pArray[0]);
                        write(clnt_sock, msg, strlen(msg));
                        log_file(msg);
                        shutdown(clnt_sock, SHUT_WR);
#if 1   // for MCU
                        shutdown(client_info[i].fd, SHUT_WR);
                        client_info[i].fd = -1;
#endif
                        break;
                    }
                    if (!strcmp(client_info[i].pw, pArray[1])) {
                        // ID와 비밀번호가 일치하는 경우
                        strcpy(client_info[i].ip, inet_ntoa(clnt_adr.sin_addr));
                        pthread_mutex_lock(&mutx);
                        client_info[i].index = i;
                        client_info[i].fd = clnt_sock;
                        clnt_cnt++;
                        pthread_mutex_unlock(&mutx);
                        sprintf(msg, "[%s] New connected! (ip:%s,fd:%d,sockcnt:%d)\n",
                                pArray[0], inet_ntoa(clnt_adr.sin_addr), clnt_sock, clnt_cnt);
                        log_file(msg);
                        write(clnt_sock, msg, strlen(msg));
                        pthread_create(t_id + i, NULL, clnt_connection, (void *)(client_info + i));
                        pthread_detach(t_id[i]);
                        break;
                    }}}
            if (i == MAX_CLNT) {
                // 인증 실패한 경우
                sprintf(msg, "[%s] Authentication Error!\n", pArray[0]);
                write(clnt_sock, msg, strlen(msg));
                log_file(msg);
                shutdown(clnt_sock, SHUT_WR);
            }
        } else {
            // 읽기 실패한 경우
            shutdown(clnt_sock, SHUT_WR);
        }}
    return 0;
}
// 클라이언트 쓰레드 함수
void *clnt_connection(void *arg) {
    CLIENT_INFO *client_info = (CLIENT_INFO *)arg;
    int str_len = 0;
    int index = client_info->index;
    char msg[BUF_SIZE];
    char to_msg[MAX_CLNT * ID_SIZE + 1];
    int i = 0;
    char *pToken;
    char *pArray[ARR_CNT] = {0};
    char strBuff[130] = {0};

    // 메시지 정보 구조체 및 첫 번째 클라이언트 정보 설정
    MSG_INFO msg_info;
    CLIENT_INFO *first_client_info;

    first_client_info = (CLIENT_INFO *)((void *)client_info - (void *)(sizeof(CLIENT_INFO) * index));

    // 클라이언트로부터 메시지를 읽어옴
    while (1) {
        memset(msg, 0x0, sizeof(msg));
        str_len = read(client_info->fd, msg, sizeof(msg) - 1);

        if (str_len <= 0)
            break;
        msg[str_len] = '\0';
        pToken = strtok(msg, "[:]");
        i = 0;
        while (pToken != NULL) {
            pArray[i] = pToken;
            if (i++ >= ARR_CNT)
                break;
            pToken = strtok(NULL, "[:]");
        }
        // 메시지 정보 설정
        msg_info.fd = client_info->fd;
        msg_info.from = client_info->id;
        msg_info.to = pArray[0];
        sprintf(to_msg, "[%s]%s", msg_info.from, pArray[1]);
        msg_info.msg = to_msg;
        msg_info.len = strlen(to_msg);

        sprintf(strBuff, "msg : [%s->%s] %s", msg_info.from, msg_info.to, pArray[1]);
        log_file(strBuff);
        // 메시지 전송
        send_msg(&msg_info, first_client_info);
    }
    // 클라이언트 소켓 종료
    close(client_info->fd);
    sprintf(strBuff, "Disconnect ID:%s (ip:%s,fd:%d,sockcnt:%d)\n", client_info->id,
            client_info->ip, client_info->fd, clnt_cnt - 1);
    log_file(strBuff);

    // 뮤텍스를 이용하여 클라이언트 카운트 갱신
    pthread_mutex_lock(&mutx);
    clnt_cnt--;
    client_info->fd = -1;
    pthread_mutex_unlock(&mutx);

    return 0;
}
// 메시지 전송 함수
void send_msg(MSG_INFO *msg_info, CLIENT_INFO *first_client_info) {
    int i = 0;

    if (!strcmp(msg_info->to, "ALLMSG")) {
        // 모든 클라이언트에게 메시지 전송
        for (i = 0; i < MAX_CLNT; i++)
            if ((first_client_info + i)->fd != -1)
                write((first_client_info + i)->fd, msg_info->msg, msg_info->len);
    } else if (!strcmp(msg_info->to, "IDLIST")) {
        // 모든 클라이언트의 ID 목록을 전송
        char *idlist = (char *)malloc(ID_SIZE * MAX_CLNT);
        msg_info->msg[strlen(msg_info->msg) - 1] = '\0';
        strcpy(idlist, msg_info->msg);

        for (i = 0; i < MAX_CLNT; i++) {
            if ((first_client_info + i)->fd != -1) {
                strcat(idlist, (first_client_info + i)->id);
                strcat(idlist, " ");
            }}
        strcat(idlist, "\n");
        write(msg_info->fd, idlist, strlen(idlist));
        free(idlist);
    } else {
        // 특정 클라이언트에게 메시지 전송
        for (i = 0; i < MAX_CLNT; i++)
            if ((first_client_info + i)->fd != -1)
                if (!strcmp(msg_info->to, (first_client_info + i)->id))
                    write((first_client_info + i)->fd, msg_info->msg, msg_info->len);
    }}
// 에러 메시지 출력 함수
void error_handling(char *msg) {
    fputs(msg, stderr);
    fputc('\n', stderr);
    exit(1);
}
// 로그 파일에 메시지 출력 함수
void log_file(char *msgstr) {
    fputs(msgstr, stdout);
}

 

make 파일로 빌드

1. make 파일 작성

# 컴파일러 설정
CC := gcc

# 실행 파일 이름
TARGET_SRV := chat_server
TARGET_CLN := chat_client

# 링크 및 스레딩 플래그
LDFLAGS := -D_REENTRANT -pthread

# 소스 파일
SRV_SOURCES := chat_server.c
CLN_SOURCES := chat_client.c

# 목적 파일
SRV_OBJECTS := $(SRV_SOURCES:.c=.o)
CLN_OBJECTS := $(CLN_SOURCES:.c=.o)

# 모든 목표 파일 빌드 규칙
all: $(TARGET_SRV) $(TARGET_CLN)

# chat_server 실행 파일 빌드 규칙
$(TARGET_SRV): $(SRV_OBJECTS)
	$(CC) -o $@ $(SRV_OBJECTS) $(LDFLAGS)

# chat_client 실행 파일 빌드 규칙
$(TARGET_CLN): $(CLN_OBJECTS)
	$(CC) -o $@ $(CLN_OBJECTS) $(LDFLAGS)

# 개별 소스 파일을 목적 파일로 컴파일 규칙
%.o: %.c
	$(CC) -c -o $@ $<

# 목적 파일 및 실행 파일 정리 규칙
clean:
	rm -f *.o $(TARGET_SRV) $(TARGET_CLN)

# 모든 파일, 실행 파일 포함 정리 규칙
clean_all:
	rm -f *.o $(TARGET_SRV) $(TARGET_CLN)

2. 빌드 결과

server, client 모두 성공적으로 빌드됨 

cleint, server 빌드 결과

server, client 프로그램 실행   

1. server 실행

프로그램 + 포트 번호를 입력하여 서버 프로그램 실행

2. client 실행

프로그램 + 서버 ip + 포트 번호 + 등록된 아이디를 입력하여 클라이언트 프로그램 실행 

결과 확인 

1. 등록된 ID로 클라이언트 프로그램을 실행하여 성공적으로 서버와 연결되고
   서버에 해당 계정 접속됨 메시지가 출력되었음  
2. 클라이언트에서 전체 채팅 메시지를 보낸 결과 서버 및 자신의 클라이언트에 해당 메시지가 출력되었음
3. 클라이언트에서 연결을 종료시 서버에서 Disconnect ID : KHJ_LIN + ip 주소 출력됨

서버에서 채팅 받은 후 화면에 출력 이후 다시 클라이언트에게 보냄

클라이언트에서 채팅 보냄

연결 종료시 서버 메시지