source: libcf/trunk/src/cf_socket.c@ 165

/**
 * \file cf_socket.c
 *
 * \author myusgun <myusgun@gmail.com>
 *
 * \brief TCP 소켓 구현
 */
#include "cf_socket.h"
#include "cf_local.h"
#include "cf_error.h"
#include "cf_util.h"

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

#if defined(_WIN32) || defined(_WIN64)
/* for windows {{{ */
# include <WinSock2.h>
# pragma comment (lib, "ws2_32.lib")
/* }}} for windows */
#else
/* for linux/unix {{{ */
# include <netinet/in.h>
# include <sys/socket.h>
# include <arpa/inet.h>
# include <netdb.h>
# include <unistd.h>
# include <sys/un.h>
# include <fcntl.h>
# include <errno.h>
# include <sys/types.h>
# include <sys/time.h>
/* }}} for linux/unix */
#endif

#define ASSERT_CTX(__ctx)   \
    if (__ctx == NULL)      \
        return CF_ERROR_SOCKET_INVALID_CTX

#define ASSERT_ARGS(x)  \
    if ((x))            \
        return CF_ERROR_SOCKET_INVALID_ARGS

#define ASSERT_INIT()                   \
    if (!CF_Socket_IsInitialized ())    \
        return CF_ERROR_SOCKET_NOT_INITIALIZED 

#define TRY_INIT()                  \
    if (CF_Socket_Initialize ())    \
        return CF_ERROR_SOCKET_NOT_INITIALIZED 

#define ASSERT_SOCKET(__sock)   \
    if (__sock < 0)             \
        return CF_ERROR_SOCKET_INVALID_SOCKET

#if defined(_WIN32) || defined(_WIN64)
typedef int                 socklen_t;
# define sa_family_t        unsigned short
# define close(__sock)      closesocket(__sock)
# define ERROR_INTR         WSAEINTR
#else
# define ERROR_INTR         EINTR
#endif

#define MAX_IP_LENGTH   256

typedef struct __cf_socket_ctx__
{
    int             sock;
    int             timeout;
    char            ip[MAX_IP_LENGTH];
    unsigned short  port;
} CF_SOCKET_CONTEXT;

static CF_BOOL gInitialized = CF_FALSE;

static void
CF_Socket_Local_SetNonBlocking (const int   sock,
                                CF_BOOL     boolean)
{
#if defined(_WIN32) || defined(_WIN64)
    unsigned long mode = (boolean) ? 1 : 0;
    ioctlsocket (sock, FIONBIO, &mode);
#else
    int flags = fcntl (sock, F_GETFL, 0);

    if (boolean)    flags |=  O_NONBLOCK;
    else            flags &= ~O_NONBLOCK;

    fcntl (sock, F_SETFL, flags);
#endif
}

static int
CF_Socket_Local_SetOption (const int    sock,
                           const int    optname,
                           const void   * optval,
                           const size_t optlen)
{
    int result = 0;

    ASSERT_SOCKET (sock);

    result = setsockopt (sock,
                         SOL_SOCKET,
                         optname,
#if defined(_WIN32) || defined(_WIN64)
                         (char *) optval,
#else
                         optval,
#endif
                         (socklen_t) optlen);
    if (result < 0)
        return CF_ERROR_SOCKET_SET_OPTION;

    return CF_OK;
}

static int
CF_Socket_Local_GetOption (const int    sock,
                           const int    optname,
                           void         * optval,
                           size_t       * optlen)
{
    int result = 0;

    ASSERT_SOCKET (sock);

    result = getsockopt (sock,
                         SOL_SOCKET,
                         optname,
#if defined(_WIN32) || defined(_WIN64)
                         (char *) optval,
#else
                         optval,
#endif
                         (socklen_t *) optlen);
    if (result < 0)
        return CF_ERROR_SOCKET_GET_OPTION;

    return CF_OK;
}

static int
CF_Socket_Local_SetLinger (const int sock)
{
    struct linger linger;

    linger.l_onoff = 1;
    linger.l_linger = 0;

    return CF_Socket_Local_SetOption (sock,
                                      SO_LINGER,
                                      &linger,
                                      sizeof (linger));
}

static int
CF_Socket_Local_SetReUseAddr (const int sock)
{
    int reuseaddr = 1;

    return CF_Socket_Local_SetOption (sock,
                                      SO_REUSEADDR,
                                      &reuseaddr,
                                      sizeof (reuseaddr));
}

static int
CF_Socket_Local_CheckTimeout (const int sock,
                              const int timeout)
{
    int             result = 0;
    fd_set          readfds;
    struct timeval  tv;
    int             error;

    if (timeout <= CF_SOCKET_NO_TIMEOUT)
        return CF_OK;

    tv.tv_sec = timeout;
    tv.tv_usec = 0;

    FD_ZERO (&readfds);
    FD_SET (sock, &readfds);

    while ((result = select (sock + 1, &readfds, NULL, NULL, &tv)) < 0)
    {
        error = CF_Util_GetSystemError ();
        if (error != ERROR_INTR)
        {
            result = CF_ERROR_SOCKET_TIMEOUT;
            return result;
        }
    }

    if (FD_ISSET (sock, &readfds) == 0)
        return CF_ERROR_SOCKET_CHECK_DESC_SET;

    return CF_OK;
}

/**
 * 소켓의 초기화 상태 확인
 *
 * \return 초기화 된 경우, CF_TRUE; 그렇지 않은 경우, CF_FALSE
 */
static CF_BOOL
CF_Socket_IsInitialized (void)
{
    return gInitialized;
}

/**
 * 소켓 초기화
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 */
int
CF_Socket_Initialize (void)
{
    if (!CF_Socket_IsInitialized ())
    {
#if defined(_WIN32) || defined(_WIN64)
        WSADATA winsockData;
        if (WSAStartup (MAKEWORD (2, 0), &winsockData))
            return CF_ERROR_SOCKET_INITIALIZE;
#endif
        gInitialized = CF_TRUE;
    }
    
    return CF_OK;
}

/**
 * 소켓 해제
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 */
int
CF_Socket_Finalize (void)
{
    ASSERT_INIT ();

#if defined(_WIN32) || defined(_WIN64)
    if (WSACleanup ())
       return CF_ERROR_SOCKET_FINALIZE;
#endif

    return CF_OK;
}

/**
 * 소켓 컨텍스트 생성
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트
 */
int
CF_Socket_Create (cf_ctx * ctx)
{
    int result = 0;

    CF_SOCKET_CONTEXT * context = NULL;

    ASSERT_CTX (ctx);

    TRY
    {
        context = NEWCTX (CF_SOCKET_CONTEXT);
        if (context == NULL)
        {
            result = CF_ERROR_SOCKET_CREATE_CTX;
            TRY_BREAK;
        }

        context->sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (context->sock < 0)
        {
            result = CF_ERROR_SOCKET_CREATE;
            TRY_BREAK;
        }

        context->timeout = CF_SOCKET_NO_TIMEOUT;
        *ctx = (CF_SOCKET_CONTEXT *) context;
    }
    CATCH_IF (result < 0)
    {
        CF_Socket_Close (context);
    }

    return result;
}

/**
 * 소켓 닫기
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트
 */
int
CF_Socket_Close (cf_ctx ctx)
{
    int result = 0;
    int sock = 0;

    CF_SOCKET_CONTEXT * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);
    ASSERT_SOCKET (context->sock);

    sock = context->sock;

    free (context);

    result = close (sock);

    if (result != 0)
        return CF_ERROR_SOCKET_CLOSE;

    return CF_OK;
}

/**
 * 소켓 연결
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트
 * \param ip    연결할 호스트의 주소 (도메인 이름 가능)
 * \param port  연결할 호스트의 포트번호
 */
int
CF_Socket_Connect (cf_ctx               ctx,
                   const char           * ip,
                   const unsigned short port)
{
    int                 result = 0;
    int                 sock = 0;
    int                 timeout = 0;
    struct sockaddr_in  address;
    struct hostent      * hostEnt;

    int                 retval = 0;
    size_t              length = 0;
    struct timeval      tv;
    fd_set              readfds;
    fd_set              writefds;

    CF_SOCKET_CONTEXT   * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (ctx);
    TRY_INIT ();

    /* 1. get and set socket info. */
    sock = context->sock;
    snprintf (context->ip, sizeof (context->ip), "%s", ip);
    context->port = port;
    timeout = context->timeout;

    /* 2. set data */
    address.sin_family      = AF_INET;
    address.sin_port        = htons (port);
    address.sin_addr.s_addr = inet_addr (ip);

    TRY
    {
        /* 3. get ip from hostname if inet_addr() is failed */
        if (address.sin_addr.s_addr == (unsigned int)-1)
        {
            hostEnt = gethostbyname (ip);
            if (hostEnt == NULL)
            {
                result = CF_ERROR_SOCKET_GET_HOST;
                TRY_BREAK;
            }

            address.sin_family = (sa_family_t) hostEnt->h_addrtype;
            memcpy (&(address.sin_addr.s_addr),
                    hostEnt->h_addr,
                    (size_t) hostEnt->h_length);
        }

        /* 4. set options */
        if (CF_Socket_Local_SetLinger (sock)    < 0 ||
            CF_Socket_Local_SetReUseAddr (sock) < 0 )
        {
            result = CF_ERROR_SOCKET_SET_OPTION;
            TRY_BREAK;
        }

        if (timeout > CF_SOCKET_NO_TIMEOUT)
            CF_Socket_Local_SetNonBlocking (sock, CF_TRUE);

        /* 5. connect */
        result = connect (sock, (struct sockaddr *) &address, sizeof (address));
        if (result == 0)
        {
            result = CF_OK;
            TRY_BREAK;
        }

        /* 6. if connect() is returned, check timeout */
        if (timeout == CF_SOCKET_NO_TIMEOUT)
        {
            result = CF_ERROR_SOCKET_TIMEOUT;
            TRY_BREAK;
        }

        FD_ZERO (&readfds);
        FD_SET ((unsigned int)sock, &readfds);
        writefds = readfds;

        tv.tv_sec = timeout;
        tv.tv_usec = 0;

        result = select (sock + 1, &readfds, &writefds, NULL, &tv);
        if (result == 0)
        {
            result = CF_ERROR_SOCKET_TIMEOUT;
            TRY_BREAK;
        }

        if (FD_ISSET (sock, &readfds) || FD_ISSET (sock, &writefds))
        {
            length = sizeof (retval);
            retval = 0;

            result = CF_Socket_GetOption (ctx, SO_ERROR, &retval, &length);
            if (result < 0)
            {
                result = CF_ERROR_SOCKET_GET_OPTION;
                TRY_BREAK;
            }
            else if (retval)
            {
                result = CF_ERROR_SOCKET_CONNECT;
                TRY_BREAK;
            }
        }
        else
        {
            result = CF_ERROR_SOCKET_CONNECT;
            TRY_BREAK;
        }
    }
    CATCH_IF (result < 0)
    {
        CF_Socket_Close (ctx);
        return result;
    }

    if (timeout > CF_SOCKET_NO_TIMEOUT)
        CF_Socket_Local_SetNonBlocking (sock, CF_FALSE);

    return result;
}

/**
 * 서버 열기
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * \param ctx       소켓 컨텍스트
 * \param port      서버 포트
 * \param backlog   listen 시의 backlog 수
 */
int
CF_Socket_Server (cf_ctx                ctx,
                  const unsigned short  port,
                  const int             backlog)
{
    int                 result = 0;
    int                 sock = 0;
    struct sockaddr_in  address;

    CF_SOCKET_CONTEXT   * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (ctx);
    TRY_INIT ();

    sock = context->sock;
    context->port = port;

    address.sin_family      = AF_INET;
    address.sin_addr.s_addr = htonl (INADDR_ANY);
    address.sin_port        = htons (port);

    TRY
    {
        if (CF_Socket_Local_SetLinger (sock)    < 0 ||
            CF_Socket_Local_SetReUseAddr (sock) < 0 )
        {
            result = CF_ERROR_SOCKET_SET_OPTION;
            TRY_BREAK;
        }

        result = bind (sock, (struct sockaddr *) &address, sizeof (struct sockaddr));
        if (result < 0)
        {
            result = CF_ERROR_SOCKET_BIND;
            TRY_BREAK;
        }

        snprintf (context->ip, sizeof (context->ip),
                  "%s",
                  inet_ntoa(address.sin_addr));

        result = listen (sock, backlog);
        if (result < 0)
        {
            result = CF_ERROR_SOCKET_LISTEN;
            TRY_BREAK;
        }
    }
    CATCH_IF (result < 0)
    {
        CF_Socket_Close (ctx);
    }

    return result;
}

/**
 * 소켓 연결 받기
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * \param ctx       소켓 컨텍스트
 * \param client    연결을 수락할 client 소켓 컨텍스트
 */
int
CF_Socket_Accept (const cf_ctx  ctx,
                  cf_ctx        * client)
{
    int                 result = 0;
    struct sockaddr_in  address;
    socklen_t           len = sizeof (address);

    CF_SOCKET_CONTEXT   * clntctx = NULL;
    CF_SOCKET_CONTEXT   * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);
    ASSERT_CTX (client);
    ASSERT_SOCKET (context->sock);

    result = CF_Socket_Create ((cf_ctx *)&clntctx);
    if (result < 0)
        return result;

    close (clntctx->sock);

    clntctx->sock = accept (context->sock, (struct sockaddr *) &address, &len);
    if (clntctx->sock < 0)
    {
        CF_Socket_Close ((cf_ctx *)clntctx);
        return CF_ERROR_SOCKET_ACCEPT;
    }

    *client = (cf_ctx) clntctx;

    return CF_OK;
}

/**
 * 데이터 송신
 *
 * \return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트 * \param buf    송신할 데이터
 * \param len   송신할 데이터의 길이
 */
int
CF_Socket_Send (const cf_ctx    ctx,
                const void      * buf,
                const size_t    len)
{
    int result = 0;

    CF_SOCKET_CONTEXT   * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);
    ASSERT_SOCKET (context->sock);

    result = (int) send (context->sock, buf, len, 0);
    if ((size_t) result != len)
        return CF_ERROR_SOCKET_SEND;

    return CF_OK;
}

/**
 * 데이터 수신
 *
 * \return 성공 시, 수신한 데이터의 길이; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트
 * \param buf   데이터를 수신할 버퍼
 * \param len   데이터를 수신할 버퍼의 최대 크기
 */
int
CF_Socket_Recv (const cf_ctx    ctx,
                void            * buf,
                const size_t    len)
{
    int result = 0;

    CF_SOCKET_CONTEXT   * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);
    ASSERT_SOCKET (context->sock);

    result = CF_Socket_Local_CheckTimeout (context->sock, context->timeout);
    if (result < 0)
        return result;

    result = (int) recv (context->sock, buf, len, 0);
    if (result < 0)
        return CF_ERROR_SOCKET_RECV;

    return result;
}

/**
 * 소켓 옵션 설정
 *
 * \return 성공 시 CF_OK; 실패 시, 오류 코드
 *
 * \param ctx       소켓 컨텍스트
 * \param optname   옵션 이름
 * \param optval    설정할 옵션 값의 메모리
 * \param optlen    설정할 옵션의 길이
 */
int
CF_Socket_SetOption (const cf_ctx   ctx,
                     const int      optname,
                     const void     * optval,
                     const size_t   optlen)
{
    CF_SOCKET_CONTEXT * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);

    return CF_Socket_Local_SetOption (context->sock,
                                      optname,
                                      optval,
                                      optlen);
}

/**
 * 소켓 옵션 얻기
 *
 * \return 성공 시 CF_OK; 실패 시, 오류 코드
 *
 * \param ctx       소켓 컨텍스트
 * \param optname   옵션 이름
 * \param optval    옵션 값을 가져올 메모리
 * \param optlen    옵션 길이를 가져올 메모리
 */
int
CF_Socket_GetOption (const cf_ctx   ctx,
                     const int      optname,
                     void           * optval,
                     size_t         * optlen)
{
    CF_SOCKET_CONTEXT * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);

    return CF_Socket_Local_GetOption (context->sock,
                                      optname,
                                      optval,
                                      optlen);
}

/**
 * 소켓 컨텍스트에 타임아웃 설정
 *
 * \return CF_OK 반환
 *
 * \param ctx       소켓 컨텍스트
 * \param timeout   설정할 타임아웃 시간
 */
int
CF_Socket_SetTimeOut (cf_ctx    ctx,
                      int       timeout)
{
    CF_SOCKET_CONTEXT * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);

    context->timeout = timeout;

    return CF_OK;
}

/**
 * 소켓 컨텍스트에 타임아웃 설정
 *
 * \return 성공 시 CF_OK; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트
 * \param ip    ip 주소를 저장할 충분한 공간의 메모리
 */
int
CF_Socket_GetIP (const cf_ctx   ctx,
                 char           * ip)
{
    CF_SOCKET_CONTEXT * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_CTX (context);
    ASSERT_ARGS (ip == NULL);

    snprintf (ip, sizeof (context->ip), "%s", context->ip);

    return CF_OK;
}

/**
 * 소켓 컨텍스트에 타임아웃 설정
 *
 * \return 성공 시 CF_OK; 실패 시, 오류 코드
 *
 * \param ctx   소켓 컨텍스트
 * \param port  포트 번호 저장할 포인터
 */
int
CF_Socket_GetPort (const cf_ctx     ctx,
                   unsigned short   * port)
{
    CF_SOCKET_CONTEXT * context = (CF_SOCKET_CONTEXT *) ctx;

    ASSERT_ARGS (port == NULL);

    *port = context->port;

    return CF_OK;
}