소켓관련된 일들을 포괄하는 ?TEpollSocket class 제작해 보자. 목표는 사용자(즉, 이 클래스를 이용해서 서버짤사람)가 아주 이용하기 편하도록 하자는 것.

1 클래스 설계 고민 = 삽질 --; #

며칠동안 고민을 했음. 고민의 순서를 짚어보자.

1. main 프로그래머가 경험이 있고 응용력이 있다면, 샘플 소스만 보고 얼마든지 짤 수 있을텐데 구태여 왜? ... 그렇지만 뭔가 찝찝하다.
   
2. Client 클래스까지 만들어줘버리고, Socket클래스가 클라이언트 생성, 소멸까지 알아서 다 해버리도록 하자. 아주 깔끔하고 편하다 (인터넷에 돌아다니는 c++소스들도 대부분 이런 골격이다). 하지만 Client 클래스가 복잡해질수록 이 구조는 끔찍할 듯 하다. 게다가 epoll 함수들도 끌고 댕겨야 한다. 독립모듈로 분리할 수가 없다.
   
3. 소켓이벤트에 콜백함수를 연결시키자!! 소켓들에서 무슨일이 생기면 내가 만든 함수가 호출되도록 구성한다. ?CSock 등이 이런방식을 취하고 있다. 하지만 함수의 포인터 다루기가 만만치 않다. 여러 종류의 Client들이 존재할 경우에 프로그램은 이루말할 수 없이 복잡해진다.
   
4. 좋다! template를 이용하자. ?BasicClient 클래스를 제공해주고 사용자로 하여금 이것을 상속받아 멋대로 클래스를 만들도록 하고, 이런 커스터마이징된 Client 클래스를 파라미터로 하는 template socket class 를 만들자!!
   
   

생각이 4번까지 하는동안 실제로 이것들을 구현해보면서 소스를 100번도 넘게 수정하고 개선하였다. 이 ?TEpollSocket 클래스를 이용해서 채팅서버는 물론 상업적 온라인게임까지 구현이 가능하도록 많은 생각을 해 내야만 했다.

물론 더 나은 설계가 가능하다면, 언제든지 조언을 ... !!

2 구현의 순서 #

1. 먼저 template 없이 기본소켓클라이언트 클래스 ?TEpollClient 구현
   
2. 마찬가지로 template 없이 기본 소켓 클래스 ?TEpollClass 구현
   
3. 동작 테스트 - 역시 echo 서버 --;
   
4. 소켓클래스 ?TEpollClass의 Client 클래스를 탬플릿으로 구현
   
5. 마찬가지로, ?TEpollClient를 상속한 나의 클래스 ?TClient 구현
   
6. 동작 테스트 - echo 서버 완성 !!
   
   

3 구현#1 : 사용자 입장에서 먼저 보자 #

3.1 main()부터 보자 #

int main(void)
{
    int n;
    TEpollSocket<TClient> esock(MAX_CLIENT);

    esock.Listen(8000);

    for(;;){
        esock.Do(10);
    }
} 

?TEpollSocket으로 esock 이라는 객체를 생성했는데, 초기값으로 몇개의 동시접속을 처리할 것인가를 정하도록 하고 있다. template로 ?TClient를 지정하도록 하였는데, 이 클래스는 ?TEpollClient를 상속받아 사용자가 만든 클래스이다.

3.2 ?TEpollClient ? #

class TEpollClient
{
protected :
    int fd; 
    char addr[MAX_ADDR];

public :
    TEpollClient(const int fd, const char *addr)
    {
        this->fd = fd;
        strcpy(this->addr, addr);
    };
    virtual int OnRead(void) = NULL;
    virtual int OnWrite(void) = NULL;
    virtual int OnError(const int nerror) = NULL;

}; 

pure virtual 3개를 가지고있는 평범한 class 이다. 물론 순수가상함수는 당신이 구현해야 한다.

3.3 ?TClient : public ?TEpollClient 구현 #

class TClient : public TEpollClient
{
public :
    TClient(const int lfd, const char *laddr) : TEpollClient(lfd, laddr)
    {
        // 초기화때 추가적으로 해주고싶은 일들이 있다면 여기에 ...
    };

    virtual int OnRead(void);
    virtual int OnWrite(void);
    virtual int OnError(const int nerror);
}; 

선언 자체는 특별한 것은 없고, 생성자에서 부모클래스인 ?TEpollClient를 그냥 바로 콜 하도록 하였다. 역시 3개의 virtual 함수들 선언을 해주었고 아래에 구현하였다. echo 서버이므로 들어온데이터를 그대로 쏜다 --;

// TEpollSocket.h 에 선언
#define EP_ERROR_NONE              1    
#define EP_ERROR_READ_CLOSE    0
#define EP_ERROR_READ_GEN      -1
#define EP_ERROR_WRITE_GEN    -2

// 사용자 구현부분
// 0 이하의 값을 리턴하면, 리턴값이 그대로 OnError로 전달된다. 실제 에러처리는 OnError에서...
int TClient::OnRead(void)
{
    char buf[1024];
    int nread, nwrite;

    nread = read(fd, buf, 1024);
    if(nread == 0) return EP_ERROR_READ_CLOSE;
    else if(nread < 0) return EP_ERROR_READ_GEN;

    // 샘플이라 이곳에 그냥 바로 echo 하도록 했다.
    nwrite = write(fd, buf, nread);
    if(nwrite < 1) return EP_ERROR_WRITE_GEN;

    return EP_ERROR_NONE;
};

// 0 이하의 값을 리턴하면, 리턴값이 그대로 OnError로 전달된다
int TClient::OnWrite(void) 
{
    // 나중에 SendBuffering 방식으로 고칠것이며, 이 곳에서 실제 flush를 해주어야 한다.
    return EP_ERROR_NONE;
};

int TClient::OnError(const int nerror)
{
    // 지금은 아무처리도 않고 그냥 리턴한다. TEpollSocket이 알아서 처리할 것이다 ;)
    cout << "Error detected : code %d\n";
    return nerror;
};  

?OnRead에서는 그냥 읽어서 다시 쏴주도록 간단히 작성했다. read 콜의 결과값이 1보다 작을 경우(즉, 0 이하인경우)는 이후 처리를 하지 않고 바로 리턴하도록 했는데 연결이 끊겼거나(0) 에러가 발생한 경우(-1) 이다. 이후에 다시 살펴보겠지만 이 리턴값을 받았을때에 ?TEpollSocket은 ?OnError를 호출한 후에 소켓연결해제(close() 호출), epoll 관심fd 삭제, ?TClient 객체 삭제를 수행하도록 작성할 것이다. 즉, ?OnRead에서 사용자는 잘 읽었는지 못 읽었는지 판별해서 적당한 값을 리턴해주도록 작성하면 된다. ?OnWrite 에서도 마찬가지. 에러처리는 ?TEpollSocket이 알아서 한다. 사용자는 어떤 일들이 일어났었는지에 관심을 가지기만 하면 된다.

여기까지 사용자 구현부분이다. 다시 정리하면, 사용자가 구현할 부분은 main과 ?TClient의 세 가상함수의 구현이다. 이 세 함수의 리턴값이 ?TEpollSocket 의 에러처리를 움직이므로 적당한 값을 리턴하는 것도 중요.

4 구현 #2 : ?TEpollSocket의 구현 #

class TEpollSocket
{
protected :
    int fd_listen;

    // 이부분은 탬플릿으로 map<int, T *> mapClient; 로 변경할 것이다.
    map<int, TEpollClient *> mapClient;
    TEpoll *epoll;

    int SetNonBlocking(int fd);

    virtual int OnEvent(TEpollEvent &event);
    virtual int OnAccept(const int fd, const char *ipaddr);
    virtual int OnDisconnect(const int fd);

public :
    TEpollSocket(const int size);
    ~TEpollSocket();
    int Listen(const unsigned nport);

// 서버라서 connect는 아직 구현하지 않음 --;
//    int Connect(...)

    int Do(int nwait);
}; 

3개의 Private 함수 On...들은 Do () 에서 파생되어 호출되는 내부함수들이다. 즉, 클래스 외부에서의 Do 호출로 이벤트들을 감지하고 무슨일이 생겼다면 각 이벤트 핸들링함수를 호출하도록 하였다. 이 함수들은 재정의 가능하다 (다만, 부모 함수를 호출해주는 처리는 해줘야 한다!)

constructor & destructor

TEpollSocket::TEpollSocket(const int size)
{
    epoll = new TEpoll(size);
    fd_listen = 0;
}

TEpollSocket::~TEpollSocket()
{   
    TEpollClient *tmpClient;

    while(! mapClient.empty() ){
        tmpClient = mapClient.begin()->second;
        delete tmpClient;
        mapClient.erase(mapClient.begin());
    }
    if(fd_listen) close(fd_listen);
    
    delete epoll;
} 

map<int, ?TEpollClient *> 이기때문에, 귀찮게 모두 delete 해줬다. 만약 포인터타입이 아닌 객체 그대로를 보관한다면 mapClient.clear(); 한줄로 끝날텐데... 하지만 객체복사같은 더 골치아픈 문제들이 있어서 포인터의 맵으로 구현했다. 직접 한번 map<int, ?TEpollClient> 형식으로 구현해 보실.

Listen() 구현

// 다른 헤더파일에 정의함
#define EP_ERROR                -3
        
#define EP_ERROR_SOCKET         -4
#define EP_ERROR_BIND           -5
#define EP_ERROR_LISTEN         -6
#define EP_ERROR_LISTEN_ALREADY -7

int TEpollSocket::Listen(const unsigned nport)
{
    if(fd_listen) return EP_ERROR_LISTEN_ALREADY;

    struct sockaddr_in server_addr, client_addr;
    int one=1, addrlen = sizeof(struct sockaddr_in);

    if ((fd_listen = socket(PF_INET, SOCK_STREAM, 0)) < 0) return EP_ERROR_SOCKET;

    bzero((char *)&server_addr, sizeof(server_addr));
    server_addr.sin_family      = PF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port        = htons(nport);

    setsockopt(fd_listen, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));

    if((bind(fd_listen, (struct sockaddr *)&server_addr, sizeof(server_addr))) < 0 ){
        close(fd_listen);
        return EP_ERROR_BIND;
    }
    
    if(listen(fd_listen, MAX_PENDING) < 0){
        close(fd_listen);
        return EP_ERROR_LISTEN;
    }
    
    // Epoll에 추가
    epoll->Add(fd_listen);
    
    return EP_ERROR_NONE;
} 

앞서 제작한 Listen과는 거의 비슷한데, 하나의 ?TEpollSocket에서 한번만 listen 하도록 했다. 물론 listen fd list를 구성하고, 접속시도가 있을때 이 리스트 검사를 하도록 수정하면 하나의 ?TEpollSocket 객체에서 여러개의 포트를 listen할 수 있으나... 개발자 입장에서는 1:1로 구성하는게 더 편할 듯 했다.

Do()의 구현

int TEpollSocket::Do(int nwait)
{
    int i, n, result;
    int fd_client;
    TEpollEvent events[MAX_EVENTS];
    struct sockaddr_in addr;
    char cliaddr[MAX_ADDR];
    int addrlen = sizeof(addr);

    if(! epoll->is_epoll_init){
        perror("epoll init error\n");
        exit(-1);
    }

    n = epoll->Do(events, MAX_EVENTS, nwait);

    for(i=0; i<n; ++i){
        // check new connection
        if(fd_listen == events[i].data.fd){
            // checking epoll_listensocket_list
            fd_client = accept(events[i].data.fd, (struct sockaddr *) &addr, (socklen_t *) &addrlen);
            if(fd_client < 0){
                continue;
            }
            strcpy(cliaddr,inet_ntoa(addr.sin_addr));
            OnAccept(fd_client, cliaddr);
        } else {
            if(OnEvent(events[i]) < 1){
                OnDisconnect(events[i].data.fd);
                close(events[i].data.fd);
                epoll->Delete(events[i].data.fd);
                break;
            }
        }
    }

    return n;
} 

Do의 구현의 핵심은, epoll_wait의 결과처리에 있다. nwait동안 기다리면서 감시하다가 이벤트가 발생한 경우, (1) fd_listen에서 일어난 일이면 ?OnAccept를 호출, (2) 다른 연결에서 일어난 일이면 ?OnEvent를 호출, (3) ?OnEvent에서 에러가 발생한 경우 ?OnDisconnect 호출 이정도의 흐름이다. 앞서 설명했지만 에러가 발생했을때에는 다음 절차를 따른다.

1. ?OnRead, ?OnWrite에서 에러발생시 에러코드 리턴 (EP_ERROR ... 시리즈)
2. ?OnEvent에서 이 코드를 받아서 ?OnError로 전달하도록 되어 있으므로, ?OnError구현시에 적절히 처리 (아무것도 안해줘도 된다만...)
3. 최종적으로 ?OnEvent는 ?OnError의 에러코드를 Do 함수에 되돌림
4. Do 함수는 ?OnDisconnect를 호출한번 한 후에 소켓종료처리.
   
   

?OnAccept()의 구현

int TEpollSocket::OnAccept(const int fd, const char *ipaddr)
{
    cout << "OnAccept\n";

    SetNonBlocking(fd);
    epoll->Add(fd);

    mapClient[fd] = new TEpollClient (fd, ipaddr);
    return mapClient.size();
} 

epoll에 관심fd를 등록하고, 새 ?TEpollClient 객체를 만들어 map<> 컨테이너에 등록하도록 하였다.

?OnEvent()의 구현

int TEpollSocket::OnEvent(TEpollEvent &event)
{
    TEpollClient *tmpClient = mapClient[event.data.fd];
    if(! tmpClient) return 1; // 에러는 아니다

    int nread, nwrite;
    char buf[1024];

    if( event.events & EPOLLIN ){
        cout << "onRead\n";
        nread = tmpClient->OnRead();
        if( nread < 1) return tmpClient->OnError(nread);
    }
    if( event.events & EPOLLOUT){
        cout << "onWrite\n";
        nread = tmpClient->OnWrite();
        if( nread < 1) return tmpClient->OnError(nread);
    }
    if( event.events & EPOLLERR){
        cout << "onError\n";
        return tmpClient->OnError(EP_ERROR_GEN);
    }

    return 1;
} 

?OnEvent의 구현은, 어떤 이벤트가 발생했는지에 따라 클라이언트의 ?OnRead, ?OnWrite, ?OnError를 호출하도록 했다. epoll_event.events가 비트셋이어서 동시에 여러개의 이벤트가 발생할 수 있으므로 에러만 없다면 모든 이벤트 처리를 다 하도록 했고, 에러가 발생하면 바로 ?OnError로 처리를 넘기도록 했다.

?OnDisconnect()의 구현

int TEpollSocket::OnDisconnect(const int fd)
{
    cout << "OnDisconnect\n";

    TEPollClient *tmpClient = mapClient[fd];
    if(! tmpClient) return -1;

    mapClient.erase(fd);
    delete tmpClient; 
            
    return mapClient.size();
} 

종료처리는, 해당 Client를 찾아서 delete 해주고 map<>컨테이너에서도 포인터를 삭제. 여기까지 해서 ?TEpollSocket의 구현이 완료!

4.1 template 적용 #

?TEpollClient를 프로그래머가 매번고쳐서 쓰도록 하기에는 너무 번거롭기 때문에, 추상화계층으로 숨겨놓고 이를 상속받아 사용하게 하려는게 원래 목적이었으므로, ?TEpollClient뿐만 아니라 이 자식들 중 어떤것이라도 커스터마이즈하여 사용하려면 template로 구현하는 수밖에 없을 듯하다. (앞에서도 썼지만 더 나은 방법이 있다면 알려주세요)

완성된 ?TEpollSocket

template <class T>
class TEpollSocket
{
private :
    int fd_listen;

    map<int, T*> mapClient;
    TEpoll *epoll;

    int SetNonBlocking(int fd);
    virtual int OnEvent(TEpollEvent &event);
    virtual int OnAccept(const int fd, const char *ipaddr);
    virtual int OnDisconnect(const int fd);

public :
    TEpollSocket(const int size);
    ~TEpollSocket();
    int Listen(const unsigned nport);
    int Do(int nwait);
}; 

4.2 Sources / ?EpSocket ver 1.0 #

• source_Makefile_echo.out
• source_ep.h
• source_ep.cc
• source_epsocket.h
• source_epclient.h
• source_epclient.cc
• source_echo.cc
  
  

5 이후의 구현계획 #

1. Read, Write의 버퍼링 구현
2. 클라이언트 <-> 서버간 메시징 구현
3. 최종완성된 소켓클래스를 이용하여 채팅서버 구현