[C]서버 클라이언트 모델 네트워크 프로그래밍

1. 개요
이번학기에 배웠던 네트워크 프로그래밍 개념을 총 집합해서
Linux에서 C로 서버-클라이언트 프로그래밍 모델을 만들어서
간단한 채팅 및 게임이 돌아가는 서버/클라이언트 프로그램을 작성해 보았다.
이번학기 네트워크 프로그래밍 과목의 프로젝트이기도 했다.

2. 수행과정
수행과정을 대략적으로 도식화하여 표현해 보면 아래와 같다.

3. 서버
먼저 서버 소스 이다.
서버 소스에서 유의 깊게 봐야 될 부분은
소켓의 생성 및 설정 과정, 소켓의 바인드 하기 위한 정보들의 구조체를 세팅하는 부분,
epoll의 수행과정, 스트링의 가공 등이다.
스트링의 가공은 프로그래머가 가상의 패킷 세팅을 해주기 위해 필요하다고 할 수 있다.

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

#define EPOLL_SIZE 500
#define BUF_SIZE 50

enum behavior {game,ftp,chat};

struct roominfor {
  char* ip; //descriptor
  char* port;
  char* name; //room manager id
  enum behavior roombe;
};

void error_handling(char *message);
char *simple_itoa(int i);
void loginserver(int portnum);
void testserver(int portnum);

int main(int argc, char *argv[])
{
  pid_t pid;
  int portnumber; //loginserver portnumber
    
  if(argc!=2) {
    printf("Usage : %s <port>\n", argv[0]);
    exit(1);
  }
    
  portnumber = atoi(argv[1]);
  
  if((pid=fork())==0) {
    //멀티 쓰레드 기반 또는 epoll형식의 서버 구현(superserver)
    //loginserver
    loginserver(portnumber);
  }

if((pid=fork())==0) {
    //멀티 쓰레드 기반 또는 epoll형식의 서버 구현(superserver)
    //chenelserver 1
    testserver(portnumber+1);
  }
  
  if((pid=fork())==0) {
    //멀티 쓰레드 기반 또는 epoll형식의 서버 구현(superserver)
    //chenelserver 2
    testserver(portnumber+2);
  }

if((pid=fork())==0) {
    //멀티 쓰레드 기반 또는 epoll형식의 서버 구현(superserver)
    //chenelserver 3
    testserver(portnumber+3);
  }
  return 0;
}

void loginserver(int portnum) {
  int chport = portnum + 1;
  int serv_sock, clnt_sock;
  struct sockaddr_in serv_adr, clnt_adr;
  socklen_t adr_sz;
  int str_len, i;
  char buf[BUF_SIZE];

struct epoll_event *ep_events;
  struct epoll_event event;
  int epfd, event_cnt;

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(portnum);
  
  if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
    error_handling("bind() error");
  if(listen(serv_sock, 200)==-1)
    error_handling("listen() error");

epfd=epoll_create(EPOLL_SIZE);
  ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);

event.events=EPOLLIN;
  event.data.fd=serv_sock;  
  epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);

while(1)
  {
    event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
    if(event_cnt==-1)
    {
      puts("epoll_wait() error");
      break;
    }

void testserver(int portnum) {
  int serv_sock, clnt_sock;
  struct sockaddr_in serv_adr, clnt_adr;
  socklen_t adr_sz;
  int str_len, i;
  char buf[BUF_SIZE];

struct epoll_event *ep_events;
  struct epoll_event event;
  int epfd, event_cnt;
  struct roominfor rooms[200];
  int roomcount = 0;

epfd=epoll_create(EPOLL_SIZE);

ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);

event.events=EPOLLIN;
  event.data.fd=serv_sock;  
  epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);

while(1)
  {
    event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
    if(event_cnt==-1)
    {
      puts("epoll_wait() error");
      break;
    }

for(i=0; i<event_cnt; i++)
    {
      if(ep_events[i].data.fd==serv_sock)
      {
        adr_sz=sizeof(clnt_adr);
        clnt_sock=
          accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
        event.events=EPOLLIN;
        event.data.fd=clnt_sock;
        epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
        printf("connected client: %d \n", clnt_sock);
      }
      else
      {
          str_len=read(ep_events[i].data.fd, buf, BUF_SIZE);
          if(str_len==0)    // close request!
          {
            epoll_ctl(
              epfd, EPOLL_CTL_DEL, ep_events[i].data.fd, NULL);
            close(ep_events[i].data.fd);
            printf("closed client: %d \n", ep_events[i].data.fd);
          }
          else
          {
            //client의 요청에 대한 처리
            //create, join
            printf("buf:%s\n",buf);
            if(strncmp(buf,"$create",7)==0) {
              struct sockaddr_in tempsubserver;
              strtok(buf,":");
              
              rooms[roomcount].ip = strtok(NULL,":");
              rooms[roomcount].port = strtok(NULL,":");
              rooms[roomcount].roombe = chat;
              printf("subserverport:%s\n",rooms[roomcount].port);
              roomcount++;
              
            }
            else if(strncmp(buf,"$join",5)==0) {
              //클라이언트가 join을 요청했을경우
              int temproomcount;
              //클라이언트들에게 채널의 방정보들을 출력
              if(roomcount<1) {
                write(ep_events[i].data.fd, "This Chanel don't have room\n", 29);
              }
              else {  
                char temproominfor[2];      
                sprintf(temproominfor,"%d",roomcount);
                write(ep_events[i].data.fd,temproominfor,2);
              }
              
            }
            else if(strncmp(buf,"$room",5)==0) {
              //클라이언트가 룸의 대한 정보를 요구할 경우.
              struct sockaddr_in subserver;
              char* chroomnum;
              strtok(buf,":");
              chroomnum = strtok(NULL,":");
              printf("subserverport%s\n",chroomnum);              
              int intchroomnum = atoi(chroomnum);
              char tempchar[30];
              //보내기 전 데이터 가공
              //room의 입장하려한 client에게 ip와 port정보를 알려줌
              sprintf(tempchar,"%s:%s",rooms[intchroomnum].ip,rooms[intchroomnum].port);
              write(ep_events[i].data.fd,tempchar,30);              
              //subserver ip전송
              //write(ep_events[i].data.fd,subserveraddr,(sizeof(subserveraddr)/sizeof(char)));
              //구분문자 넣어주기              
              //write(ep_events[i].data.fd,"/",1); 
              //subserver port전송
              //write(ep_events[i].data.fd,subserverport,(sizeof(subserverport)/sizeof(char)));
            }
            //write(ep_events[i].data.fd, buf, str_len);    // echo!
          }
  
      }
    }
  }
  close(serv_sock);
  close(epfd);
}

char *simple_itoa(int i)
{
  /* 21 digits plus null terminator, good for 64-bit or smaller
  ints */
  /* for bigger ints, use a bigger buffer! */
  static char local[22];
  char *p = &local[21];
  *p-- = '\0';
  do {
  *p-- = '0' + i % 10;
  i /= 10;
  } while (i > 0);
  return p + 1;
}
void error_handling(char *message)
{
  fputs(message, stderr);
  fputc('\n', stderr);
  exit(1);
}

4. 클라이언트
다음으로 클라이언트 소스이다.
클라이언트에서는 멀티 쓰레드를 이용해 보았다.
멀티 쓰레드의 사용방법과 멀티 쓰레드로 채팅을 처리하는 방법 정도를 유의 깊게 보면 되겠다.

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

#define BUF_SIZE s1024
#define NAME_SIZE 20
#define MAX_CLNT 256

void error_handling(char *message);
char *simple_itoa(int i);
int newport; //연결할 채널의 포트번호
void loginconnect(char* ipaddr,int port);
void chatsubserver(void);
int sock; //clnt socket
int ch_sock; //채널연결과의 소켓 연결 
  
void * send_msg(void * arg);
void * recv_msg(void * arg);
  
char name[NAME_SIZE]="[DEFAULT]";
char msg[BUF_SIZE];

void * handle_clnt(void * arg);
void server_send_msg(char * msg, int len);

int clnt_cnt=0;
int clnt_socks[MAX_CLNT];

pthread_mutex_t mutx;

int main(int argc, char *argv[])
{
  
  char message[BUF_SIZE];
  int str_len;
  struct sockaddr_in serv_adr, serv_adr_2;

if(argc!=3) {
    printf("Usage : %s <IP> <port>\n", argv[0]);
    exit(1);
  }

//로그인서버와의 연결
  loginconnect(argv[1],atoi(argv[2]));
  
  //새로운 프로세스와의 연결켓
  
  ch_sock=socket(PF_INET, SOCK_STREAM, 0);   
  if(ch_sock==-1)
    error_handling("socket() error");
  
  memset(&serv_adr, 0, sizeof(serv_adr));
  serv_adr.sin_family=AF_INET;
  serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
  serv_adr.sin_port=htons(newport);
  
  if(connect(ch_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
    error_handling("connect() error!");
  else
    puts("Connected...........");
  while(1) 
  {
    char choicemenu;
    printf("원하시는 메뉴를 선택해주세요. \n");
    printf("1 방만들기 (create)\n");
    printf("2 방들어가기(Join)\n");
    printf("메뉴외에 다른 메뉴를 선택하시면 종료됩니다.\n");    
    fputs("Yourchoice: ", stdout);
    choicemenu=getchar();
    //fgets(message, BUF_SIZE, stdin);
    if(choicemenu=='1') {
      //create
      char createcommand[30];
      char *hostip;
      char *hostport;
      struct sockaddr_in hostinfor;
      int tempsize = sizeof(hostinfor);
      getsockname(ch_sock, (struct sockaddr *)&hostinfor, &tempsize);
      
      hostip = inet_ntoa(hostinfor.sin_addr);
      //새로 만들게 될 포트번호는 ch_sock과 연결된 포트번호+1
      hostport = simple_itoa(ntohs(hostinfor.sin_port)+1); 
      printf("subserverport:%s\n",hostport);
      sprintf(createcommand,"$create:%s:%s", hostip, hostport);    
      write(ch_sock, createcommand, 30);
      chatsubserver();
    }
    else if(choicemenu=='2') {
      //join
      write(ch_sock, "$join", 5);
      printf("clnt join read before\n");
      str_len=read(ch_sock, message, BUF_SIZE-1);
      printf("%s\n",message);
      printf("clnt join read after\n");
      int roomofnumber = atoi(message);
      int i;      
      for(i=0;i<roomofnumber;i++) {
        printf("room number : %d\n", i);
      }
      printf("Plese choice roomber :");
      int choiceroomnum;
      scanf("%d",&choiceroomnum);
      char tempchar[7];
      //fgets(message, BUF_SIZE, stdin);
      sprintf(tempchar,"$room:%d",choiceroomnum);
      write(ch_sock, tempchar, 7);
      char subserverinfor[BUF_SIZE];
      char *subserverip;
      char *subserverport;
      str_len=read(ch_sock, subserverinfor, BUF_SIZE-1);
      subserverip=strtok(subserverinfor,":");
      subserverport=strtok(NULL,":");
      printf("subip:%s\n",subserverip);
      printf("subport:%s\n",subserverport);
      //서버서버와의 연결을 위한 환경설정
      int sock2;
      sock2=socket(PF_INET, SOCK_STREAM, 0);
      memset(&serv_adr_2, 0, sizeof(serv_adr_2));
      serv_adr_2.sin_family=AF_INET;
      serv_adr_2.sin_addr.s_addr=inet_addr(subserverip);
      serv_adr_2.sin_port=htons((atoi(subserverport)));
      //서브 서버와의 연 결
      if(connect(sock2, (struct sockaddr*)&serv_adr_2, sizeof(serv_adr_2))==-1)
        error_handling("connect() error!");
      else
        puts("Connected...........");
      pthread_t snd_thread, rcv_thread;
      void * thread_return;
      pthread_create(&snd_thread, NULL, send_msg, (void*)&sock2);
      pthread_create(&rcv_thread, NULL, recv_msg, (void*)&sock2);
      pthread_join(snd_thread, &thread_return);
      pthread_join(rcv_thread, &thread_return);
      close(sock2);  
    }
    else {
      //1,2번과 다른 선택을 하였을 시
      break;
    }

write(ch_sock, message, strlen(message));
    str_len=read(ch_sock, message, BUF_SIZE-1);
    message[str_len]=0;
    printf("Message from server: %s", message);
  }
  close(ch_sock);
  return 0;
}

void loginconnect(char* ipaddr,int port) {
  int login_sock;
  char message[BUF_SIZE];
  int str_len;
  struct sockaddr_in serv_adr;
  login_sock=socket(PF_INET, SOCK_STREAM, 0);   
  if(sock==-1)
    error_handling("socket() error");
  
  memset(&serv_adr, 0, sizeof(serv_adr));
  serv_adr.sin_family=AF_INET;
  serv_adr.sin_addr.s_addr=inet_addr(ipaddr);
  serv_adr.sin_port=htons(port);
  
  if(connect(login_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
    error_handling("connect() error!");
  else
    puts("Connected...........");
  
  while(1) 
  {
    fputs("ID (Q to quit): ", stdout);
    fgets(message, BUF_SIZE, stdin);
    strtok(message,"\n");
    char tempmessage2[BUF_SIZE];
    strncpy(tempmessage2,message,(sizeof(message)-2));
    sprintf(name, "[%s]", tempmessage2);
    if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))
      break;
    write(login_sock, message, strlen(message));
    write(login_sock, "/id", strlen(message));
    str_len=read(login_sock, message, BUF_SIZE-1);
    printf("server:%s\n",message);
    if(strcmp(message,"/port")) {
      break;
    }
  }
  int i;
  char portnum[4];
  for(i=0;i<4;i++) {
    portnum[i] = message[str_len-9+i];
  }
  newport = atoi(portnum);
  close(login_sock);
}

void chatsubserver(void) {
  int chat_serv_sock, chat_clnt_sock;
  struct sockaddr_in serv_adr, clnt_adr, temp_adr;
  int clnt_adr_sz;
  pthread_t t_id;
  int temp_adr_len = sizeof(temp_adr);
  //채널과 서브서버간의 연결된 소켓의 정보 얻어오기  
  getsockname(ch_sock, (struct sockaddr *)&temp_adr, &temp_adr_len);
  
  pthread_mutex_init(&mutx, NULL);
  //서브서버 소켓 생성
  chat_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((ntohs(temp_adr.sin_port)+1));
  
  if(bind(chat_serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
    error_handling("bind() error");
  if(listen(chat_serv_sock, 5)==-1)
    error_handling("listen() error");
  
  printf("port:%d\n",ntohs(serv_adr.sin_port));
  while(1)
  {
    int str_len;
    char msg[BUF_SIZE];
    clnt_adr_sz=sizeof(clnt_adr);
    printf("chatserver accpt before\n");
    chat_clnt_sock=accept(chat_serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz);
    printf("chatserver accpt after\n");
    pthread_mutex_lock(&mutx);
    clnt_socks[clnt_cnt]=chat_clnt_sock;
    clnt_cnt++;
    pthread_mutex_unlock(&mutx);
    printf("chatserver thread create before\n");
    pthread_create(&t_id, NULL, handle_clnt, (void*)&chat_clnt_sock);
    pthread_detach(t_id);
    printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
  }
  close(chat_serv_sock);
}

void * handle_clnt(void * arg)
{
  int clnt_sock=*((int*)arg);
  int str_len=0, i;
  char msg[BUF_SIZE];
  
  while((str_len=read(clnt_sock, msg, sizeof(msg)))!=0) {  
    char ricevemsg[BUF_SIZE];
    strcpy(ricevemsg,msg);
    char* sendid = NULL;
    char* sendtoid; //누구에게 보낼지
    char* sendmsgtemp; //보낼메시지 임시저장    
    sendid = strtok(ricevemsg,"[]");  
    //보낸 사람의 아이디는 sendid로 저장
    char* sendmsg;
    sendmsg = strtok(NULL,sendid);
    if(strncmp(sendid,"sendto",6)==0) {
      //귓속말 커맨드이면      
      char msg2[BUF_SIZE];
      
      str_len=read(clnt_sock, msg2, sizeof(msg));
      char tempmsg2[BUF_SIZE];
      strcpy(tempmsg2,msg2);
      //printf("%s\n",msg2);
      sendid = strtok(msg2,"[]");
      //printf("%s\n",sendid);      
      sendtoid = strtok(NULL," ");
      sendtoid = strtok(sendtoid,"/");
      //printf("%s\n",sendtoid);
      sendmsgtemp = strtok(tempmsg2," ");
      sendmsgtemp = strtok(NULL," ");
      sendmsgtemp = strtok(NULL," ");
      //printf("%s\n",sendmsgtemp);
      char request[100];  
      sprintf(request,"ID:[%s] [%s]%s", sendtoid, sendid, sendmsgtemp);    
      server_send_msg(request, 100);
    }
    else {
      server_send_msg(msg, str_len);
    }
  }
  
  pthread_mutex_lock(&mutx);
  for(i=0; i<clnt_cnt; i++)   // remove disconnected client
  {
    if(clnt_sock==clnt_socks[i])
    {
      while(i++<clnt_cnt-1) {
        clnt_socks[i]=clnt_socks[i+1];
      }
      break;
    }
  }
  clnt_cnt--;
  pthread_mutex_unlock(&mutx);
  close(clnt_sock);
  return NULL;
}

void server_send_msg(char * msg, int len)   // send to all
{
  int i;
  pthread_mutex_lock(&mutx);
  for(i=0; i<clnt_cnt; i++)
    write(clnt_socks[i], msg, len);
  pthread_mutex_unlock(&mutx);
}

void * send_msg(void * arg)   // send thread main
{
  int sock=*((int*)arg);
  char name_msg[NAME_SIZE+BUF_SIZE];
  while(1) 
  {
    fgets(msg, BUF_SIZE, stdin);
    if(!strcmp(msg,"q\n")||!strcmp(msg,"Q\n")) 
    {
      close(sock);
      exit(0);
    }
    if(strncmp(msg,"/",1)==0) {
      write(sock, "sendto", 6);
    }
    sprintf(name_msg,"%s %s", name, msg);
    write(sock, name_msg, strlen(name_msg));
  }
  return NULL;
}
  
void * recv_msg(void * arg)   // read thread main
{
  int sock=*((int*)arg);
  char name_msg[NAME_SIZE+BUF_SIZE];
  int str_len;
  while(1)
  {
    char *wantclnt;
    str_len=read(sock, name_msg, NAME_SIZE+BUF_SIZE-1);
    if(str_len==-1) 
      return (void*)-1;
    name_msg[str_len]=0;
    if(strncmp(name_msg,"ID:",3)==0) {
      char ricevemsg[BUF_SIZE];
      char *chpoint;
      char *messagetemp;
      strcpy(ricevemsg, name_msg);
      chpoint = strtok(ricevemsg,"ID:");

chpoint = strtok(chpoint," ");
      //printf("toclnt:%s\n",chpoint);
      messagetemp = strtok(NULL," ");
      if(strcmp(chpoint,name)==0) {
        fputs(messagetemp, stdout);
      }
    }
    else {
      fputs(name_msg, stdout);
    }
  }
  return NULL;
}

void error_handling(char *message)
{
  fputs(message, stderr);
  fputc('\n', stderr);
  exit(1);
}

저작자표시

'Programing > Network Programing' 카테고리의 다른 글

[Winpcap] 간단한 스니퍼 프로그램 예제. (1)	2012.03.27
[Winpcap] winpcap 시작 레퍼런스 (0)	2012.03.27
[C/C++] Windows ICMP Flood Programing (2)	2011.05.28
소켓의 생성과정 (0)	2011.01.13

White Memo

[C]서버 클라이언트 모델 네트워크 프로그래밍

'Programing > Network Programing' 카테고리의 다른 글

티스토리툴바

[C]서버 클라이언트 모델 네트워크 프로그래밍

'Programing > Network Programing' 카테고리의 다른 글

'Programing/Network Programing' Related Articles

티스토리툴바