기억창고

chatServer.c

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <sys/epoll.h>                     // 이게 중요

#include <arpa/inet.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <errno.h>

#define EPOLL_SIZE 60

#define EPOLL_EVENT_SIZE 100

#define OPENPORT 9000                       // open port 번호

// main

int

main (int argc, char **argv)

{

        struct epoll_event *events;          // epoll 관련

        struct epoll_event ev;        

        struct sockaddr_in addr, clientaddr;

        int clilen;

        int sfd, efd, cfd;                   // server 소켓, epoll 소켓, client 소켓

        int i,j;                             // for문을 위해

        int max_got_events;

        int result;

        int readn;

        int sendflags = 0;

        char buf_in[256] = { '\0' };         // 버퍼

        int count = 0;

 
        // epoll 소켓 생성

        if ((efd = epoll_create (EPOLL_EVENT_SIZE)) < 0)

        {

                perror ("epoll_create (1) error");

                return -1;

        }

        // init pool

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

        if (NULL == events)

        {

                perror ("epoll_create (0) error");

                return -1;

        }

 
        // 서버 소켓 생성

        clilen = sizeof (clientaddr);

        sfd = socket (AF_INET, SOCK_STREAM, 0);

        if (sfd == -1)

        {

                perror ("socket error :");

                close (sfd);

                return -1;

        }

        // 소켓 정보 넣고 bind, listen 처리 

        addr.sin_family = AF_INET;

        addr.sin_port = htons (OPENPORT);

        addr.sin_addr.s_addr = htonl (INADDR_ANY);

        if (bind (sfd, (struct sockaddr *) &addr, sizeof (addr)) == -1)

        {

                close (sfd);

                return -2;

        }

        listen (sfd, 5);

        if (sfd < 0)

        {

                perror ("init_acceptsock error");

                return 1;

        }

        // 서버시작, epoll 이벤트 설정 및 컨트롤 함수로 활성화 

        printf("Running Server port %d\n",OPENPORT);

        ev.events = EPOLLIN;

        ev.data.fd = sfd;

        result = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &ev);

        if (result < 0)

        {

                perror ("epoll_ctl error");

                return 1;

        }

        // 서버 실제 루트
        while (1)

        {

                // epoll 이벤트 대기 (클라이언트의 반응(접속 or send) 감지)
                max_got_events = epoll_wait (efd, events, EPOLL_SIZE, -1);

             
                // epoll 이벤트 받은만큼의 숫자만큼 for
                for (i = 0; i < max_got_events; i++)

                {

                        // 이벤트 들어온 소켓이 연결 요청이면
                        if (events[i].data.fd == sfd)

                        {

                                cfd = accept (sfd, (struct sockaddr *)

                                                &clientaddr, &clilen);

                                if (cfd < 0)

                                {

                                        perror ("Accept error");

                                        return -1;

                                }

                                ev.events = EPOLLIN;

                                ev.data.fd = cfd;

                                epoll_ctl (efd, EPOLL_CTL_ADD, cfd, &ev);

                                printf("Accepted socket : %d\n",cfd);

                                count++;

                        }

                        // 그게 아니면,
                        else

                        {

                                cfd = events[i].data.fd;

                                memset (buf_in, 0x00, 256);

                                readn = read (cfd, buf_in, 255);

                                // if it occured ploblems with reading,

                                // delete from epoll event pool and close socket                                                                                                                        // readn 값이 0 이하이면 recv 처리

                                if (readn <= 0)

                                {

                                        epoll_ctl(efd, EPOLL_CTL_DEL, cfd, &ev);

                                        close (cfd);

                                        printf ("Close fd %d\n", cfd);

                                        count--;

                                }

                                else

                                {

                                // 아니면 send 처리
                                //      printf ("%s", buf_in);

                                        for(j=5; j<count+5; j++)

                                        {

                                          // 단 이벤트로온 client엔 send 하지말고
                                          // 다른 모든 클라이언트에 send 해서 채팅
                                                if(cfd != j)

                                                        send (j, buf_in,

                                                         strlen (buf_in),

                                                         sendflags);

                                        }

                                }

                        }

                }

        }

        return 1;

}

Server.cpp

#include <winsock2.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#define MAXLINE 512

#define MAX_SOCK 64

char *escapechar = "exit";

int maxfdp1;

int num_chat = 0;                                                                               // 채팅참가자수

int client_s[MAX_SOCK];

// 채팅탈퇴처리

void removeClient(int)                              // i번째참가자탈퇴

{

        closesocket(client_s[i]);                   // 해당소켓닫기

        if(i !=num_chat -1)

               client_s[i] = client_s[num_chat -1]; 

        num_chat --;                                // 채팅참가자수1명줄이기

        printf("채팅참가자1명탈퇴. 현재참가자수= %d\n",num_chat);

}

// client_s[]내의최대소켓번호얻기(k는초기치)

int getmax(int k)

{

        int max = k;

        int r;

        for(r = 0; r < num_chat ; r++)            // 채팅참가자수만큼소켓배열탐색

               if(client_s[r] > max)

                       max = client_s[r];

        return max;

}

int main()

{

        char rline[MAXLINE], my_msg[MAXLINE];               // buffer 생성

        char *start = "Connetctd to chat_server\n";         // 최초연결시보내는메세지

        int i,j,n;

        SOCKET s, client_fd, clilen;

        fd_set read_fds;

        struct sockaddr_in client_addr, server_addr;        // 소켓주소구조체선언

        WSADATA wsa;                                        // 윈소켓

        // 윈속초기화

        if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)

               exit(1);

        // 초기소켓생성

        if((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)

        {

               printf("Server: Can't open stream socket.");

               exit(0);

        }

        // server_addr 구조체의내용세팅

        ZeroMemory(&server_addr, sizeof(server_addr));       //초기화(0으로채운다)

        server_addr.sin_family = AF_INET;

        server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

        server_addr.sin_port = htons(9000);

         
        // bind()
        if(bind(s,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0 )     
        {

               printf("Server: Can't bind local address.\n");

               exit(0);

        }

        //클라이언트로부터연결요청을기다림

        listen(s,SOMAXCONN);                    // listen 접속대기(큐크기5)

        maxfdp1 = s + 1;                        // 최대소켓번호+1

        while(1)

        {

               FD_ZERO(&read_fds);              // fd_set  초기화(0으로세팅) 

               FD_SET(s,&read_fds);       // 소켓에해당하는file discripter를1로세팅

               for(i=0; i<num_chat; i++)        // ""

                       FD_SET(client_s[i], &read_fds);

               maxfdp1 = getmax(s) +1;         // maxfdp1 재계산

               if(select(maxfdp1,&read_fds, (fd_set  *)0, (fd_set *) 0, (struct timeval *) 0) < 0)     // select setting

               {

                       printf("select error =< 0 \n");

                       exit(0);

               }

               if(FD_ISSET(s, &read_fds))  // read_fds 중s에해당하는비트가세팅되있다면

               {              

                       int addrlen;        // 의미없음ㅡㅡ.. 단순주소길이저장변수

                       addrlen = sizeof(client_addr);

                       // == 연결요청이있다면

                       clilen = sizeof(client_addr);

                       client_fd = accept(s, (struct sockaddr *)&client_addr, &addrlen);                 
                        //  accept()

                       if(client_fd == -1)

                       {

                              printf("accept error \n");

                              exit(0);

                       }

                       // 채팅클라이언트목록에추가

                       client_s[num_chat] = client_fd;

                       num_chat++;                       // 채팅참가자수1 증가

                   
    // "Connetctd to chat_server" 를접속한클라이언트에보냄                    
                       send(client_fd,start,strlen(start),0);     
                       printf("%d번째사용자추가,\n",num_chat);

               }

               //클라이언트가보낸메시지를모든클라이언트에게방송

               for(i = 0; i<num_chat; i++)              // 모든클라이언트검색

               {

                       memset(rline,'\0',MAXLINE);      // buffer 초기화

                       if(FD_ISSET(client_s[i],&read_fds)) 
                      // read 해당소켓에서read 할것이있는지확인

                       {

                              if((n = recv(client_s[i],rline,MAXLINE, 0 )) <= 0)

                              {

                                      removeClient(i);

                                      continue;

                              }

                              // 종료문자처리

                              if(strstr(rline,escapechar) != NULL)
                              //"exit"가입력되면종료시키기

                              {

                                      removeClient(i);

                                      continue;

                              }

                              // 모든채팅참가자에게메시지방송

                              rline[n] = '\0';

                              for(j = 0; j < num_chat; j++)

                                      send(client_s[j],rline,n,0);

                              printf("%s\n",rline);

                       }

               }

        }

        closesocket(s);                                                                                                                                                        // closesocket()

        WSACleanup();                                                                                                                                                  // 윈속종료

        return 0;

}

Client.cpp

/***********************************************

        스레드를사용한채팅클라이언트

   원래루트는recv 전용이고

   스레드를생성해서사용자입력대기하다가,

   입력받게되면send 해주는클라이언트임.

***********************************************/

#include <winsock2.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#define MAXLINE     512

DWORD WINAPI ProcessInputSend(LPVOID arg);

char *escapechar = "exit";

char name[10]; // 채팅에서사용할이름

char line[MAXLINE], message[MAXLINE+1];

struct    sockaddr_in   server_addr;

SOCKET s;      // 서버와연결된소켓번호

int main()

{

        WSADATA wsa;                          // 윈속

        // 채팅참가자이름구조체초기화

        printf("채팅ID 입력: ");

        scanf("%s",name);

        // 윈속초기화

        if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)

               exit(1);

        // 소켓생성

        if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)

        {

               printf("Client : Can't open stream socket.\n");

               exit(0);

        }

        // 채팅서버의소켓주소구조체server_addr 초기화

        ZeroMemory(&server_addr, sizeof(server_addr));

        server_addr.sin_family = AF_INET;

        server_addr.sin_port = htons(9000);

        server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

        // 연결요청

        if(connect(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)

        {

               printf("Client : Can't connect to server.\n");

               exit(0);

        }

        else

        {

               printf("서버에접속되었습니다. \n");

        }

        // 스레드생성

        HANDLE hThread;

        DWORD ThreadId;

        hThread = CreateThread(NULL, 0, ProcessInputSend, 0, 0, &ThreadId);

        if(hThread == NULL)

               printf("[오류] 스레드생성실패!\n");

        else

               CloseHandle(hThread);

        while(1)

        {

               ZeroMemory(message, sizeof(message));

               int size;

               if((size = recv(s, message, MAXLINE, 0)) == SOCKET_ERROR)

               {

                       printf("recv()");

                       exit(0);

               }

               else

               {

                       message[size] = '\0';

                       printf("%s \n", message);

               }

        }

        closesocket(s);                       // closesocket()

        WSACleanup();                 // 윈속종료

}

// 사용자입력부분

DWORD WINAPI ProcessInputSend(LPVOID arg)

{

        while(true)

        {

               if(fgets(message, MAXLINE, stdin))

               {

                       sprintf(line, "[%s] %s", name, message);

                       if (send(s, line, strlen(line), 0) < 0)

                              printf("Error : Write error on socket.\n");

                       if (strstr(message, escapechar) != NULL )

                       {

                              printf("Good bye.\n");

                              closesocket(s);

                              exit(0);

                       }

               }

        }

        return 0;

}