base

fhs/csagentd/lib/BaseSocket.cpp

@@ -0,0 +1,595 @@
+#include "BaseSocket.h"
+
+
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+
+
+#define SOCKET_NOT_VALID		-1
+#define MAX_SEND_RETRY_COUNT	10	// Socket send 실패시 최대 재전송 시도 횟수.
+
+
+/// @brief 생성자.
+/// @param socket [in] 처리할 socket descriptor
+CBaseSocket::CBaseSocket( const int& socket )
+	: m_sock( socket )
+{
+	if( m_sock < 0 )
+	{
+		m_sock = SOCKET_NOT_VALID;
+		m_bConnected = false;
+	}
+	else
+	{
+		m_bConnected = true;
+	}
+}
+
+/// @brief 소멸자
+CBaseSocket::~CBaseSocket()
+{
+	// 소멸자 Socket 명시적 Close 처리.
+	Close();
+}
+
+/// @brief 소켓의 Close 처리를 수행함.
+void CBaseSocket::Close()
+{
+	m_bConnected = false;
+
+	if( m_sock != SOCKET_NOT_VALID )
+	{
+		close( m_sock );
+		m_sock = SOCKET_NOT_VALID;
+	}
+}
+
+/// @brief 전달받은 Target 으로 Socket 접속을 수행
+/// @param szTarget [in] 접속 대상 Host name 또는 IP
+/// @param nPort	[in] 접속 Port
+/// @return 접속 성공시 true, 실패시 false 반환. ( 오류 내역은 로깅처리됨.)
+bool CBaseSocket::Connect( const std::string& szTarget, int nPort )
+{
+	// 기존 접속을 Close 처리
+	Close();
+
+	unsigned int nHost = ConversionAddr( szTarget.c_str() );
+	if( nHost == INADDR_NONE )
+	{
+		LOG( LERR, "target host name resolve fail. [%s]->INADDR_NONE", szTarget.c_str());
+		return false;
+	}
+
+	struct sockaddr_in stTargetAddr;
+
+	m_sock = socket(AF_INET, SOCK_STREAM, 0);
+	if( m_sock == -1 )
+	{
+		int errorNum = errno;
+
+		LOG( LERR, "socket create failed.[%d][%s] Target:[%s]", errorNum, strerror(errorNum), szTarget.c_str() );
+
+		m_sock = SOCKET_NOT_VALID;
+		return false;
+	}
+
+	stTargetAddr.sin_family = AF_INET;
+	stTargetAddr.sin_addr.s_addr = nHost;
+	stTargetAddr.sin_port = htons( nPort );
+
+	// NEW 2012-05-18 huibong
+	// Connnection 종료시 많은 TIME_WAIT 상태 발생으로 인해 .. 이를 제거하기 위해 SO_LINGER 옵션을 설정처리한다.
+	struct linger opt_linger;
+	opt_linger.l_onoff  = 1; /* LINGER ON */
+
+	// CHG 2014-05-27 huibong
+	// 아래와 같이 No Wait 로 처리할 경우... Server 역활 수행 중 Close 신호를 받지 못하는 경우가 발생 가능함.
+	// 따라서 5 sec 정도 대기하도록 수정 처리한다.
+	//opt_linger.l_linger = 0; /* No Wait => 0 for abortive disconnect */
+	opt_linger.l_linger = 5; // 5 sec 대기
+
+	int result = setsockopt( m_sock, SOL_SOCKET, SO_LINGER, &opt_linger, sizeof(opt_linger));
+	if( result != 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "setsockopt func SO_LINGER set fail.[%d][%s]", errorNum, strerror(errorNum));
+
+	}
+
+	/* Send Timeout 설정. */
+	struct timeval tv_timeo = { 5, 0 };
+	
+	result = setsockopt( m_sock, SOL_SOCKET, SO_SNDTIMEO, &tv_timeo, sizeof(tv_timeo));
+	if( result != 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "setsockopt func SO_SNDTIMEO set fail.[%d][%s]", errorNum, strerror(errorNum));
+
+	}
+
+	if(connect(m_sock, (struct sockaddr *)&stTargetAddr, sizeof(stTargetAddr)) < 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "connect fail.[%s][%d] [%d][%s]", szTarget.c_str(), nPort, errorNum, strerror( errorNum ) );
+
+		Close();
+		return false;
+	}
+	else
+	{
+		m_bConnected = true;
+		return true;
+	}
+}
+
+
+/// @brief 멤버 변수인 m_sock 이 유효하고 연결된 상태인 경우 true 반환.
+/// @return socket이 유효하지 않거나 연결이 끊어지 경우 false 반환, 그외에는 true 반환.
+bool CBaseSocket::IsValidSocket()
+{
+	if( m_sock != SOCKET_NOT_VALID && m_bConnected == true )
+		return true;
+	else
+		return false;
+}
+
+/// @brief m_sock 으로부터 지정된 size 만큼 데이터 read 를 시도 ( read 함수와 동일 )
+/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+/// @param size [in] read 하고자 하는 데이터의 크기.
+/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류 
+ssize_t CBaseSocket::Read( void * vptr, size_t size )
+{
+	if( IsValidSocket() == false )
+		return 0;
+
+	ssize_t nRead = 0;
+	while( (nRead = read( m_sock, vptr, size )) < 0 )
+	{
+		int errorNum = errno;
+		if( errorNum == EINTR || errorNum == EAGAIN || errorNum == EWOULDBLOCK )
+		{
+			nRead = 0;
+			continue;
+		}
+		else if( errorNum == ECONNRESET || errorNum == EPIPE ) 
+		{
+			// 2010-07-23 BUG huibong 잘못된 대입연산자를 비교연산자로 수정.
+			// 2015-08-28 CHG huibong EPIPE(32) 오류 발생시.. 연결 종료로 처리되도록 수정
+			m_bConnected = false;
+			return 0;
+		}
+		else
+		{
+			LOG( LERR, "read func fail.[%d][%s]", errorNum, strerror(errorNum) );
+			return -1;
+		}
+	}
+
+	return nRead;
+}
+
+/// @brief m_sock 로부터 지정된 size 만큼 read 를 시도, \n
+///< 만약 지정된 크기만큼 데이터가 존재하지 않을 경우 해당 크기만큼 데이터를 read 할때까지 대기.
+/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+/// @param size [in] read 하고자 하는 데이터의 크기.
+/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류 
+ssize_t CBaseSocket::ReadN( void * vptr, size_t size )
+{
+	if( IsValidSocket() == false )
+		return 0;
+
+	ssize_t nRead = 0;
+	size_t  nLeft = size;
+	char * ptr = (char *)vptr;
+	
+	while( nLeft > 0 )
+	{
+		if( (nRead = read( m_sock, ptr, nLeft )) < 0 )
+		{
+			int errorNum = errno;
+			if( errorNum == EINTR || errorNum == EAGAIN || errorNum == EWOULDBLOCK )
+			{
+				nRead = 0;
+				continue;
+			}
+			else if( errorNum == ECONNRESET || errorNum == EPIPE )
+			{
+				// 2015-08-28 CHG huibong EPIPE(32) 오류 발생시.. 연결 종료로 처리되도록 수정
+				m_bConnected = false;
+				return 0;
+			}
+			else
+			{
+				LOG( LERR, "read func fail.[%d][%s]", errorNum, strerror(errorNum) );
+				return -1;
+			}
+		}
+		else if( nRead == 0 )
+		{
+			m_bConnected = false;
+			return 0;
+		}
+
+		nLeft -= nRead;
+		ptr   += nRead;
+	}
+
+	return size;
+}
+
+/// @brief m_sock 로부터 지정된 size 만큼 read 를 시도, \n
+///< 만약 지정된 크기만큼 데이터가 존재하지 않을 경우 해당 크기만큼 데이터를 read 할때까지 대기. \n
+///< 또는 지정된 Timeout 값 동안 read 를 하지 못하는 경우 오류 처리.
+/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+/// @param size [in] read 하고자 하는 데이터의 크기.
+/// @param timeout [in] Timeout value (sec)
+/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류 , -2: Timeout
+ssize_t CBaseSocket::ReadNTimeout( void * vptr, size_t size, int timeout )
+{
+	if( IsValidSocket() == false )
+		return 0;
+
+	ssize_t nRead = 0;
+	size_t  nLeft = size;
+	char * ptr    = (char *)vptr;
+	
+	struct timeval timeOver;
+	int result;
+
+	fd_set selectFds;
+	FD_ZERO( &selectFds );
+
+	while( nLeft > 0 )
+	{
+		timeOver.tv_sec  = timeout;
+		timeOver.tv_usec = 0;
+		FD_SET( m_sock, &selectFds );
+
+		result = select( m_sock+1, &selectFds, (fd_set *)NULL, (fd_set *)NULL, &timeOver );
+
+		if( result > 0 )
+		{
+			if( FD_ISSET( m_sock, &selectFds ))
+			{
+				if( (nRead = read( m_sock, ptr, nLeft) ) < 0 )
+				{
+					int errorNum = errno;
+					if(errorNum == EINTR || errorNum == EAGAIN || errorNum == EWOULDBLOCK)
+					{
+						nRead = 0;
+						continue;
+					}
+					else if( errorNum == ECONNRESET || errorNum == EPIPE )
+					{
+						// 2015-08-28 CHG huibong EPIPE(32) 오류 발생시.. 연결 종료로 처리되도록 수정
+						m_bConnected = false;
+						return 0;
+					}
+					else
+					{
+						LOG( LERR, "read func fail.[%d][%s]", errorNum, strerror(errorNum) );
+						return -1;
+					}
+				}
+				else if( nRead == 0 )
+				{
+					m_bConnected = false;
+					return 0;
+				}
+
+				nLeft -= nRead;
+				ptr   += nRead;
+			}
+
+		}
+		else if( result == 0 ) // Timeout
+		{
+			//LOG( LDBG, "read timeout");
+			return -2;
+		}
+		else
+		{
+			int errorNum = errno;
+			LOG( LERR, "select func error.[%d][%s]", errorNum, strerror(errorNum) );
+			
+			return -1;
+		}
+	}
+
+	return size;
+}
+
+/// @brief m_sock 로부터 지정된 size 만큼 read 를 시도, \n
+///< 만약 지정된 크기만큼 데이터가 존재하지 않을 경우 해당 크기만큼 데이터를 read 할때까지 대기. \n
+///< 또는 지정된 Timeout 값 동안 read 를 하지 못하는 경우 오류 처리.
+///< 본 함수는 Socket 상에 이미 Data 가 존재하는 경우에만 사용.
+/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+/// @param size [in] read 하고자 하는 데이터의 크기.
+/// @param timeout [in] Timeout value (sec)
+/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류, -2: Timeout
+ssize_t CBaseSocket::ReadNTimeout2( void * vptr, size_t size, int timeout )
+{
+	if( IsValidSocket() == false )
+		return 0;
+
+	ssize_t nRead = 0;
+	size_t  nLeft = size;
+	char * ptr    = (char *)vptr;
+	int errorNum;
+
+	// 우선은 읽기 시도.
+	if( (nRead = read( m_sock, ptr, nLeft) ) < 0 )
+	{
+		errorNum = errno;
+		if( errorNum == EINTR || errorNum == EAGAIN || errorNum == EWOULDBLOCK )
+		{
+			nRead = 0;	
+		}
+		else if( errorNum == ECONNRESET || errorNum == EPIPE )
+		{
+			// 2015-08-28 CHG huibong EPIPE(32) 오류 발생시.. 연결 종료로 처리되도록 수정
+
+			m_bConnected = false;
+			return 0;
+		}
+		else
+		{
+			LOG( LERR, "read func fail.[%d][%s]", errorNum, strerror(errorNum) );
+			return -1;
+		}
+	}
+	else if( nRead == 0 )
+	{
+		m_bConnected = false;
+		return 0;
+	}
+
+	nLeft -= nRead;
+	ptr   += nRead;
+
+	// 만약 더 받을 데이터가 존재한다면.
+	if( nLeft > 0 )
+	{
+		struct timeval timeOver;
+		int result;
+
+		fd_set selectFds;
+		FD_ZERO( &selectFds );
+
+		while( nLeft > 0 )
+		{
+			timeOver.tv_sec  = timeout;
+			timeOver.tv_usec = 0;
+			FD_SET( m_sock, &selectFds );
+
+			result = select( m_sock+1, &selectFds, (fd_set *)NULL, (fd_set *)NULL, &timeOver );
+
+			if( result > 0 )
+			{
+				if( FD_ISSET( m_sock, &selectFds ))
+				{
+					if( (nRead = read( m_sock, ptr, nLeft) ) < 0 )
+					{
+						errorNum = errno;
+						if(errorNum == EINTR || errorNum == EAGAIN || errorNum == EWOULDBLOCK)
+						{
+							nRead = 0;
+							continue;
+						}
+						else if( errorNum == ECONNRESET || errorNum == EPIPE )
+						{
+							// 2015-08-28 CHG huibong EPIPE(32) 오류 발생시.. 연결 종료로 처리되도록 수정
+							m_bConnected = false;
+							return 0;
+						}
+						else
+						{
+							LOG( LERR, "read func fail.[%d][%s]", errorNum, strerror(errorNum) );
+							return -1;
+						}
+					}
+					else if( nRead == 0 )
+					{
+						m_bConnected = false;
+						return 0;
+					}
+
+					nLeft -= nRead;
+					ptr   += nRead;
+				}
+			}
+			else if( result == 0 ) // Timeout
+			{
+				//LOG( LDBG, "read timeout");
+				return -2;
+			}
+			else
+			{
+				errorNum = errno;
+				LOG( LERR, "select func error.[%d][%s]", errorNum, strerror(errorNum) );
+
+				return -1;
+			}
+		}
+	}
+
+	return size;
+}
+
+/// @brief m_sock 으로 지정된 크기만큼 vptr 의 데이터를 전송 시도.\n
+///< Send Timeout 옵션 설정으로 Write Timeout 설정 가능. \n
+///< 지정된 횟수만큼 재전송 실패시 오류로 처리함.
+/// @param vptr [in] 전달할 데이터를 저장한 변수에 대한 포인터.
+/// @param size [in] write 하고자 하는 데이터의 크기.
+/// @return write 된 데이터의 크기. 0: fd closed, -1: 오류 
+ssize_t CBaseSocket::WriteN( const void * vptr, size_t size )
+{
+	if( IsValidSocket() == false )
+		return 0;
+
+	size_t nLeft;
+	ssize_t nWrite;
+
+	const char * ptr = (const char *)vptr;
+	nLeft = size;
+
+	int nTryCount = 0;
+
+	while( nLeft > 0 )
+	{
+		if( (nWrite = send( m_sock, ptr, nLeft, 0 )) < 0 )
+		{
+			int errorNum = errno;
+
+			if( errorNum == EINTR || errorNum == EAGAIN || errorNum == EWOULDBLOCK )
+			{
+				nWrite = 0;
+				++nTryCount;
+			}
+			else if( errorNum == ECONNRESET || errorNum == EPIPE )
+			{
+				// 2015-08-28 CHG huibong EPIPE(32) 오류 발생시.. 연결 종료로 처리되도록 수정
+				m_bConnected = false;
+				return 0;
+			}
+			else
+			{
+				LOG( LERR, "send func fail.[%d][%s]", errorNum, strerror(errorNum));
+
+				return -1;
+			}
+		}
+		else if( nWrite == 0 )
+		{
+			m_bConnected = false;
+			return 0;
+		}
+
+		if( nTryCount > MAX_SEND_RETRY_COUNT )
+		{
+			LOG( LERR, "send func failure due to exceeding count of retry[%d/%d]", nTryCount, MAX_SEND_RETRY_COUNT );
+			return 0 ;
+		}
+
+		nLeft -= nWrite;
+		ptr   += nWrite;
+	}
+
+	return size;
+}
+
+// CHG 2011-05-03 huibong
+// gethostbyname() 함수가 Thread Safe 하지 않기 때문에
+// DNS resolve 처리시 잘못된 정보를 반환할 가능성이 존재
+// 이에 따라 본 함수를 수정처리함.
+/*
+unsigned int CBaseSocket::ConversionAddr( const char * name )
+{
+	struct hostent *he;
+	int max;
+	unsigned int retval;
+
+	if ((retval = inet_addr(name)) != INADDR_NONE)
+		return retval;
+
+	he = gethostbyname(name);
+	if (he == NULL) 
+		return INADDR_NONE;
+
+	for (max = 0; he->h_addr_list[max]; max++) ;
+	if (max == 1) 
+		return *((unsigned int *)(he->h_addr_list[0]));
+	else 
+		return *((unsigned int *)(he->h_addr_list[random() % max]));
+}
+*/
+
+unsigned int CBaseSocket::ConversionAddr( const char * name )
+{
+	unsigned int retval;
+	struct addrinfo hints;
+	struct addrinfo *result = NULL;
+	int error;
+
+
+	// 전달받은 정보가 IP 주소인 경우...
+	// - DNS resolve 할 필요 없이 변환시킨 값을 그대로 사용한다.
+	if( (retval = inet_addr(name)) != INADDR_NONE )
+		return retval;
+
+	// getaddrinfo() 함수 호출을 위한 Hint 설정
+	memset( &hints, 0x00, sizeof(hints));
+	hints.ai_family = PF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+
+	// Thread Safe 한 DNS Resolve 처리함수 호출
+	// int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res);
+
+	// CHG 2014-11-14 huibong
+	// getaddrinfo 호출시 종종 EAI_NONAME 오류가 반환됨. (#20783)
+	// - 따라서 오류 반환시 재시도하도록 기능 추가 
+	// CHG 2015-07-15 huibong
+	// usleep 의 multi thread 상에서 block 발생 가능
+	// - nanosleep 을 사용토록 변경 처리
+	for( int count = 0 ; count < 3; count++ )
+	{
+		error = getaddrinfo( name, NULL, &hints, &result );
+
+		// 오류 발생시
+		if( error != 0 )
+		{
+			if( result != NULL)
+			{
+				freeaddrinfo(result);
+				result = NULL;
+			}
+
+			// 잠시 대기 후 재시도 처리
+			struct timespec sleep;
+			sleep.tv_sec = 0;
+			sleep.tv_nsec = 500000000;   // 0.5 sec
+			nanosleep( &sleep, NULL );
+		}
+		else
+		{
+			// 정상 처리된 경우...
+			// - loop 탈출
+			break;
+		}
+	}
+
+	// 최종 오류 발생시
+	if( error != 0 )
+	{
+		LOG( LERR, "name[%s] dns resolve fail. getaddrinfo return error [%d][%s]", name, error, gai_strerror(error) );
+		return INADDR_NONE;
+	}
+
+	struct sockaddr_in * addr = (struct sockaddr_in *)result->ai_addr;
+	retval = (unsigned int)(addr->sin_addr.s_addr);
+
+	// DNS Resovle 결과 확인용 코드
+	/*
+	struct addrinfo *temp;
+	for( temp = result; temp; temp = temp->ai_next )
+	{
+		addr = (struct sockaddr_in *)temp->ai_addr;
+		printf ("getaddrinfo result = %s\n",inet_ntoa( addr->sin_addr));
+	}
+	*/
+
+	// getaddrinfo() 함수에서 생성한 메모리 영역 해제 처리.
+	freeaddrinfo(result);
+
+	return retval;
+
+}
+

fhs/csagentd/lib/BaseSocket.h

@@ -0,0 +1,120 @@
+/***************************************************************************
+				BaseSocket ( Base Socket Class )
+                -----------------------------------------
+	begin      : 2010/03/02
+	copyright  : (C) 2005 SolutionBox Inc.
+	author     : Service 1 Team
+	email      : svc1@solbox.com
+	version    : 1.0
+
+	CopyRight(C) 2005 SolutionBox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+
+#ifndef __LIBRARY_BASE_SOCKET_H__
+#define __LIBRARY_BASE_SOCKET_H__
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "Logger.h"
+
+#define SOCKET_NOT_VALID					-1
+#define DEFAULT_DATA_RECEIVE_TIMEOUT		15		// sec
+
+
+class CBaseSocket
+{
+
+	protected:
+
+		/// @brief socket descriptor
+		int m_sock;
+
+		/// @brief socket 의 연결상태인지 여부를 저장하기 위한 변수.
+		bool m_bConnected;
+
+
+	public:
+
+		/// @brief 생성자.
+		CBaseSocket( const int & socket );
+
+		/// @brief 소멸자.
+		~CBaseSocket();
+
+		/// @brief 소켓의 Close 처리를 수행함.
+		void Close(void);
+
+		/// @brief 전달받은 Target 으로 Socket 접속을 수행
+		/// @param szTarget [in] 접속 대상 Host name 또는 IP
+		/// @param nPort	[in] 접속 Port
+		/// @return 접속 성공시 true, 실패시 false 반환. ( 오류 내역은 로깅처리됨.)
+		bool Connect( const std::string& szTarget, int nPort );
+
+		/// @brief 멤버 변수인 m_sock 이 유효하고 연결된 상태인 경우 true 반환.
+		/// @return socket이 유효하지 않거나 연결이 끊어지 경우 false 반환, 그외에는 true 반환.
+		bool IsValidSocket(void);
+
+		/// @brief 멤버변수인 socket 의 접속 상태 여부를 설정하기 위한 함수.
+		void SetConnectionStatus( bool bConnected)	{ m_bConnected = bConnected; }
+
+		/// @brief 현재 socket 의 접속 상태를 반환.
+		bool GetConnectionStatus( void) { return m_bConnected; }
+
+		//void SetLogger( Logger * pLog ) { m_pLog = pLog; }
+
+	// telegraf hang check 관련  socket 통신 처리 때문에.. protected -> public 으로 변경 처리.
+	//protected:
+	public:
+
+		/// @brief m_sock  로 부터 지정된 size 만큼 데이터 read 를 시도 ( read 함수와 동일 )
+		/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+		/// @param size [in] read 하고자 하는 데이터의 크기.
+		/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류 
+		ssize_t Read( void * vptr, size_t size );
+
+		/// @brief m_sock 로부터 지정된 size 만큼 read 를 시도, \n
+		///< 만약 지정된 크기만큼 데이터가 존재하지 않을 경우 해당 크기만큼 데이터를 read 할때까지 대기.
+		/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+		/// @param size [in] read 하고자 하는 데이터의 크기.
+		/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류 
+		ssize_t ReadN( void * vptr, size_t size );
+
+		/// @brief m_sock 로부터 지정된 size 만큼 read 를 시도, \n
+		///< 만약 지정된 크기만큼 데이터가 존재하지 않을 경우 해당 크기만큼 데이터를 read 할때까지 대기. \n
+		///< 또는 지정된 Timeout 값 동안 read 를 하지 못하는 경우 오류 처리.
+		/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+		/// @param size [in] read 하고자 하는 데이터의 크기.
+		/// @param timeout [in] Timeout value (sec)
+		/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류, -2: Timeout
+		ssize_t ReadNTimeout( void * vptr, size_t size, int timeout = DEFAULT_DATA_RECEIVE_TIMEOUT );
+
+		/// @brief m_sock 로부터 지정된 size 만큼 read 를 시도, \n
+		///< 만약 지정된 크기만큼 데이터가 존재하지 않을 경우 해당 크기만큼 데이터를 read 할때까지 대기. \n
+		///< 또는 지정된 Timeout 값 동안 read 를 하지 못하는 경우 오류 처리.
+		///< 본 함수는 Socket 상에 이미 Data 가 존재하는 경우에만 사용.
+		/// @param vptr [out] Read 된 데이터를 저장하기 위한 변수에 대한 포인터.
+		/// @param size [in] read 하고자 하는 데이터의 크기.
+		/// @param timeout [in] Timeout value (sec)
+		/// @return read 된 데이터의 크기. 0: fd closed, -1: 오류, -2: Timeout
+		ssize_t ReadNTimeout2( void * vptr, size_t size, int timeout = DEFAULT_DATA_RECEIVE_TIMEOUT );
+
+	public:
+		/// @brief m_sock 으로 지정된 크기만큼 vptr 의 데이터를 전송 시도.\n
+		///< Send Timeout 옵션 설정으로 Write Timeout 설정 가능. \n
+		///< 지정된 횟수만큼 재전송 실패시 오류로 처리함.
+		/// @param vptr [in] 전달할 데이터를 저장한 변수에 대한 포인터.
+		/// @param size [in] write 하고자 하는 데이터의 크기.
+		/// @return write 된 데이터의 크기. 0: fd closed, -1: 오류 
+		ssize_t WriteN( const void * vptr, size_t size );
+
+	protected:
+
+		/// @brief 문자열로 전달받은 정보를 검사하여 IP 접속 정보를 생성한다.
+		unsigned int ConversionAddr( const char * name );
+
+};
+
+#endif /* __LIBRARY_BASE_SOCKET_H__ */

fhs/csagentd/lib/Config.cpp

@@ -0,0 +1,215 @@
+
+#include "Config.h"
+
+#include <iostream>
+#include <fstream>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <boost/algorithm/string.hpp>  // use boost 
+
+
+Config::Config()
+	: m_keyDelimiter( CONFIG_DEFAULT_KEY_DELIMITER )
+	  , m_valueDelimiter( CONFIG_DEFAULT_VALUE_DELIMITER )
+{
+
+}
+
+/// @brief destructor
+Config::~Config()
+{
+	Clear();
+}
+
+/// @brief 지정된 Config 파일의 모든 정보를 읽어 내부 변수에 저장처리
+/// @param path [in] Config file 의 전체 경로정보( C 배열 지원을 위해 & 사용안함)
+/// @return On success return true, otherwise return false
+bool Config::Open( const string path )
+{
+	ifstream file;
+
+	// Config file open
+	file.open( path.c_str());
+	if( file.is_open() == false )
+	{
+		cerr << "[error] " << __FILE__<< ":" << __func__ << ": config file open failed.[" << path << "][" << strerror( errno ) << "]" << endl;
+		return false;
+	}
+
+	// 기존 데이터가 존재하면 삭제 처리.
+	if( m_configData.empty() == false )
+		m_configData.clear();
+	
+	// config file parsing
+	string line;
+	string section;
+	vector< string > configs;
+
+	// 루프를 돌면서 Config 파일을 line 단위로 읽어들인당....
+	while( std::getline( file, line ) )
+	{
+		// 앞뒤 공백 제거 처리
+		boost::trim( line );
+
+		// 공백 or 주석처리 라인 검사
+		if( line.empty() == true || boost::starts_with( line, string("#") ) == true	|| line == "\r" )
+		{
+			continue;
+		}		
+
+		// Section 여부 검사
+		if( boost::starts_with( line, string("[") ) == true && boost::ends_with( line, string("]") ) == true )
+		{
+			// [] 로 정의된 section 의 문자열 값 추출
+			line.erase( line.begin() );
+			line.erase( line.end() -1 );
+			boost::trim( line );
+
+			if( section.empty() == false && section != line )
+			{
+				// 이전 세션과 다른 신규 세션인 경우
+				// 기존까지 저장했던 데이터를 멤버 변수에 입력 처리 후 내부변수 초기화 처리.
+
+				m_configData.insert( make_pair( section, configs ) );
+				section.clear();
+				configs.clear();
+			}
+
+			// 신규 section 정보 저장처리.
+			section = line;
+			line.clear();		
+		}
+		else
+		{
+			// Section 정보가 아닌 경우 => 실제 설정값 .. ^^
+			configs.push_back( line );
+		}
+	}
+
+	// 마지막 세션 처리된 정보가 존재하는 경우 멤버 변수에 저장 처리.
+	if( section.empty() == false )
+	{
+		m_configData.insert( make_pair( section, configs ) );
+	}
+
+	// 종료 처리.
+	file.close();
+	return true;
+}
+
+/// @brief Config 멤버 변수에 저장된 데이터 삭제처리.
+/// @return void
+void Config::Clear()
+{
+	m_configData.clear();
+}
+
+/// @brief 해당 Section, Key 에 해당하는 value 값을 찾아 반환
+/// @param section [in] 찾고자 하는 Section 값
+/// @param key [in] 찾고자 하는 key 값
+/// @param value [out] 해당 Section, Key 에 해당하는 value 값을 저장하기 위한 변수
+/// @return On success return true, otherwise return false
+bool Config::GetConfig( const string section, const string key, string& value )
+{
+	// Section 에 대한 임시 데이터 저장객체 생성	
+	vector< string > configs;
+	
+	// 해당 Section 이 존재하지 않는 경우 
+	if( Find( section, configs ) == false )
+		return false;
+
+	string line;
+	string result;
+	vector< string >::const_iterator it;
+
+	// 해당 Key 이 존재하는지 검사
+	for( it = configs.begin(); it != configs.end(); it++)
+	{
+		line = *it;
+
+		// Line 상의 주석 제거
+		string::size_type pos = line.find( '#' );
+		if( pos != string::npos)
+		{
+			line = line.substr(0, pos);
+			boost::trim( line );
+		}
+		
+		// key = value 에서 key 부분 추출
+		pos = line.find( m_keyDelimiter );
+		if( pos == string::npos )
+		{
+			continue;
+		}
+		else
+		{
+			result = line.substr(0, pos);
+			boost::trim( result );
+		}
+
+		if( key == result )
+		{
+			// Key 값이 동일한 경우
+			value = line.substr( pos+1 );
+			boost::trim( value );
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/// @brief 해당 Section, Key 에 해당하는 value Array 값을 찾아 반환
+/// @param section [in] 찾고자 하는 Section 값
+/// @param key [in] 찾고자 하는 key 값
+/// @param value [out] 해당 Section, Key 에 해당하는 value 값을 저장하기 위한 배열
+/// @return On success return true, otherwise return false
+bool Config::GetConfig( const string section, const string key, vector< string >& value )
+{
+	string result;
+	vector< string > vec;
+
+	if( GetConfig( section, key, result ) == false )
+		return false;
+
+	// 전달받은 result 값을 value delimiter 를 이용하여 parsing 처리 
+	boost::split( vec, result, boost::is_any_of( m_valueDelimiter ));
+	if( vec.empty() == true )
+		return false;
+
+	// 루프를 돌면서 trim 처리 후 결과값 저장처리.
+	vector< string >::const_iterator it;
+	for( it = vec.begin(); it != vec.end(); it++)
+	{
+		result = boost::trim_copy( *it );
+
+		if( result.empty() == false )
+			value.push_back( result );
+	}
+
+	if( value.empty() == true )
+		return false;
+	else
+		return true;
+}
+
+/// @brief Config 멤버 변수에 저장된 데이터 중 해당 Section 에 해당하는 데이터 반환.
+/// @param section [in] section 명
+/// @param configData [out] 해당 Section 에서 읽은 Cofig 정보를 저장할 string 배열
+/// @return On success return true, otherwise return false
+bool Config::Find( const string& section, vector<string>& configData )
+{
+	map< string, vector< string > >::iterator it = m_configData.find( section );
+	if( it != m_configData.end() )
+	{
+		// 해당 section 을 찾은 경우
+		configData = it->second;
+		return true;
+	}
+
+	// 해당 section 을 찾지 못한 경우
+	return false;
+}
+
+

fhs/csagentd/lib/Config.h

@@ -0,0 +1,114 @@
+/***************************************************************************
+                Config File Parser Class 
+                -----------------------------------------
+	begin      : 2010/02/27
+	copyright  : (C) 2005 SolutionBox Inc.
+	author     : Service 1 Team
+	email      : svc1@solbox.com
+	version    : 1.0
+
+	CopyRight(C) 2005 SolutionBox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+
+#ifndef __LIBRARY_CONFIG_H__
+#define __LIBRARY_CONFIG_H__
+
+#include <string>
+#include <map>
+#include <vector>
+
+using namespace std;
+
+
+#define CONFIG_DEFAULT_KEY_DELIMITER   "="
+#define CONFIG_DEFAULT_VALUE_DELIMITER ","
+
+
+/// @brief Config class
+/// 1. config 파일의 내용을 파싱처리하여 각 Section, Key 에 해당하는 값을 반환처리
+/// 2. config 파일은 [section] 단위로 구분된다.
+/// 3. config 파일은 key=value 로 구분가능하며 이는 Delimiter 설정을 통해 변경가능하다.
+/// 4. value 값이 다중으로 존재하는 경우 "," 값을 통해 구분가능, Delimiter 변경시 다른 값도 사용가능함.
+/// 5. config 파일상에서 "#" 로 시작하는 문자열은 라인 끝까지 주석으로 처리된다.
+/// 6. 특정 Key 값에 대한 다중 value 값 조회는 vector<string> 을 통해 수행한다.
+/// 7. 만약 다중 value 값이 존재시 string 으로 반환받을 경우 해당 Row 가 통째로 반환된다.
+/// 8. 본 객체는 Open , Clear 함수가 호출되기전까지 이전 Config 정보가 저장된다.
+class Config
+{
+	private:
+		/// @brief config information saved variable
+		// string : section data
+		// vector<string> : key=value data
+		map< string, vector< string> > m_configData;
+
+		/// @brief Key, Value 구분자 저장 변수
+		string m_keyDelimiter;
+		string m_valueDelimiter;
+
+	public:
+		/// @brief constructor
+		Config();
+		
+		/// @brief destructor
+		~Config();
+
+		/// @brief 지정된 Config 파일의 모든 정보를 읽어 내부 변수에 저장처리
+		/// @param path [in] Config file 의 전체 경로정보( C 배열 지원을 위해 & 사용안함)
+		/// @return On success return true, otherwise return false
+		bool Open( const string path );
+
+		/// @brief Config 멤버 변수에 저장된 데이터 삭제처리.
+		/// @return void
+		void Clear();
+
+		/// @brief 해당 Section, Key 에 해당하는 value 값을 찾아 반환
+		/// @param section [in] 찾고자 하는 Section 값
+		/// @param key [in] 찾고자 하는 key 값
+		/// @param value [out] 해당 Section, Key 에 해당하는 value 값을 저장하기 위한 변수
+		/// @return On success return true, otherwise return false
+		bool GetConfig( const string section, const string key, string& value );
+
+		/// @brief 해당 Section, Key 에 해당하는 value Array 값을 찾아 반환
+		/// @param section [in] 찾고자 하는 Section 값
+		/// @param key [in] 찾고자 하는 key 값
+		/// @param value [out] 해당 Section, Key 에 해당하는 value 값을 저장하기 위한 배열
+		/// @return On success return true, otherwise return false
+		bool GetConfig( const string section, const string key, vector< string >& value );
+
+		/// @brief Key, Value Delimiter Get 함수
+		/// @param key [out] key delimiter 값
+		/// @param value [out] value delimiter 값
+		void GetDelimiter( string& key, string& value )
+		{
+			key = m_keyDelimiter;
+			value = m_valueDelimiter;
+		}
+
+		// BUG 2010-12-06 huibong
+		// string& value = CONFIG_DEFAULT_VALUE_DELIMITER 값은 문법상 오류 구문임.
+		// gcc 3.4.6 버전에서는 Compile 되나 gcc 4.4.5 에서는 error 로 처리되어 수정처리함.
+
+		/// @brief Key, Value Delimiter Set 함수
+		/// @param key [out] key delimiter 값
+		/// @param value [out] value delimiter 값, 지정하지 않을 경우 Default 값이 사용됨.
+		void SetDelimiter( string& key, string value = CONFIG_DEFAULT_VALUE_DELIMITER )
+		{
+			m_keyDelimiter = key; 
+			m_valueDelimiter = value;
+		}
+
+
+	protected:
+		/// @brief Config 멤버 변수에 저장된 데이터 중 해당 Section 에 해당하는 데이터 반환.
+		/// @param section [in] section 명
+		/// @param configData [out] 해당 Section 에서 읽은 Cofig 정보를 저장할 string 배열
+		/// @return On success return true, otherwise return false
+		bool Find( const string& section, vector<string>& configData );
+
+};
+
+
+
+#endif /* __LIBRARY_CONFIG_H__ */

fhs/csagentd/lib/Logger.cpp

@@ -0,0 +1,487 @@
+/***************************************************************************
+                Logger.cpp
+                -----------------------------------------
+    begin      : 2011/10/26
+    copyright  : (C) 2005 SolutionBox Inc.
+    author     : Service 1 Team
+    email      : svc1@solbox.com
+    version    : 1.0
+    
+    CopyRight(C) 2005 SolutionBox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+#include "Logger.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <iostream>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define MAX_BUFFER_SIZE		2048  // 임시 버퍼 최대 크기
+#define DEFAULT_LOG_LEVEL	LINF
+
+using namespace std;
+
+CLogger* CLogger::m_pInstance = NULL;
+bool CLogger::m_bIsInitialized = false;
+pthread_mutex_t CLogger::m_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+
+CLogger::CLogger( string programName, string logDir, int logLevel )
+{
+	m_szProgramName = programName;
+	m_szLogDir = logDir;
+
+	if( IsValidLogLevel( logLevel ) == true )
+	{
+		m_nLogLevel = logLevel;
+	}
+	else
+	{
+		m_nLogLevel = DEFAULT_LOG_LEVEL;
+	}
+
+	MakeLogLevelString();
+}
+
+void CLogger::MakeLogLevelString()
+{
+	m_vectorLogLevelString.push_back( "EMR" );
+	m_vectorLogLevelString.push_back( "ALT" );
+	m_vectorLogLevelString.push_back( "CRT" );
+	m_vectorLogLevelString.push_back( "ERR" );
+	m_vectorLogLevelString.push_back( "WAR" );
+	m_vectorLogLevelString.push_back( "NOT" );
+	m_vectorLogLevelString.push_back( "INF" );
+	m_vectorLogLevelString.push_back( "DBG" );
+	m_vectorLogLevelString.push_back( "DEV" );
+	m_vectorLogLevelString.push_back( "DEV1" );
+	m_vectorLogLevelString.push_back( "DEV2" );
+}
+
+CLogger::~CLogger()
+{
+	m_vectorLogLevelString.clear();
+}
+
+bool CLogger::Init( string programName, string logDir, int logLevel )
+{
+	if( m_bIsInitialized == true )
+	{
+		return true;
+	}
+
+    pthread_mutex_lock( &m_mutex );
+
+	// 변수 유효성 검사.
+	if( programName.empty() == true || logDir.empty() == true )
+	{
+		pthread_mutex_unlock( &m_mutex );
+		return false;
+	}
+
+	if( IsValidLogLevel( logLevel ) == false )
+	{
+		pthread_mutex_unlock( &m_mutex );
+		return false;
+	}
+
+	if( MakeLogDir( programName, logDir ) == false )
+	{
+		pthread_mutex_unlock( &m_mutex );
+		return false;
+	}
+
+	if( CLogger::m_pInstance != NULL )
+	{
+		delete CLogger::m_pInstance;
+		CLogger::m_pInstance = NULL;
+	}
+
+	CLogger::m_pInstance = new CLogger( programName, logDir, logLevel );
+	m_bIsInitialized = true;
+
+    pthread_mutex_unlock( &m_mutex );
+
+	return true;
+}
+
+bool CLogger::IsValidLogLevel( int logLevel )
+{
+	return ( ( logLevel < 0 || logLevel > MAX_LOG_LEVEL   ) ? false : true  );
+}
+
+bool CLogger::SetLogLevel( int logLevel )
+{
+	if( IsValidLogLevel( logLevel ) == false )
+	{
+		return false;
+	}
+
+	m_nLogLevel = logLevel;
+
+	return true;
+}
+
+bool CLogger::MakeLogDir( string programName, string logDir )
+{
+	string path = logDir + "/" + programName;
+
+	struct stat dirStat;
+
+	// 해당 이름을 가진 파일 또는 디렉토리가 존재하고
+	if( lstat( path.c_str(), &dirStat ) == 0 )
+	{
+		// 해당 이름이 디렉토리인 경우 
+		if( S_ISDIR( dirStat.st_mode ) == true )
+		{
+			return true;
+		}		
+		else
+		{
+			cerr << "exist file with the same name as log path(" << path << ")." << endl;
+			return false;
+		}
+	}
+
+	// 디렉토리 가 존재하지 않는 경우 디렉토리 생성 시도
+	string cmd = "mkdir -p " + path;
+	system( cmd.c_str() );
+
+	if( IsDirectory( path ) == false )
+	{
+		cerr << "can't make log directory. path=" << path << "." << endl;
+		return false;
+	}
+
+	return true;
+}
+
+bool CLogger::IsDirectory( string path )
+{
+    struct stat dirStat;
+
+    if( lstat ( path.c_str(), &dirStat ) != 0 )
+    {
+		cerr << "Log path not valid. Check path [" << path << "][" << errno << "][" << strerror(errno) << "]" << endl;
+        return false;
+    }   
+
+    // 해당 정보가 Directory 가 아닌 경우
+    if( S_ISDIR( dirStat.st_mode ) == false )
+    {
+        return false;
+    }
+
+    return true;
+}
+
+void CLogger::Exit()
+{
+	if( m_bIsInitialized == false )
+	{
+		return;
+	}
+
+    pthread_mutex_lock( &m_mutex );
+
+	if( CLogger::m_pInstance != NULL )
+	{
+		delete CLogger::m_pInstance;
+		CLogger::m_pInstance = NULL;
+		m_bIsInitialized = false;
+	}
+
+    pthread_mutex_unlock( &m_mutex );
+}
+
+CLogger* CLogger::GetInstance()
+{
+	return CLogger::m_pInstance;
+}
+
+string CLogger::GetLogFilename( struct tm &timeNow )
+{
+	char timeStr[256];
+	snprintf( timeStr, (size_t)256, "%04d%02d%02d.log", timeNow.tm_year+1900, timeNow.tm_mon+1, timeNow.tm_mday);
+
+	// Make File Name
+	string filename = m_szLogDir + "/" + m_szProgramName + "/" + m_szProgramName + "_" + string( timeStr );
+	
+	return filename;
+}
+
+bool CLogger::Write( int logLevel, const char * fmt, ...)
+{
+	// 가변 인자 처리
+	va_list args;
+	char buffer[MAX_BUFFER_SIZE];
+	va_start( args, fmt );
+	if( vsnprintf( buffer, MAX_BUFFER_SIZE, fmt, args) < 0 )
+	{
+		va_end( args );
+		return false;
+	}
+	va_end(args);
+
+	return Write( logLevel, PREFIX_DATE, NULL, 0, buffer );
+}
+
+bool CLogger::WriteNoPrefix( int logLevel, const char * fmt, ...)
+{
+	// 가변 인자 처리
+	va_list args;
+	char buffer[MAX_BUFFER_SIZE];
+	va_start( args, fmt );
+	if( vsnprintf( buffer, MAX_BUFFER_SIZE, fmt, args) < 0 )
+	{
+		va_end( args );
+		return false;
+	}
+	va_end(args);
+
+	return Write( logLevel, PREFIX_NONE, NULL, 0, buffer );
+
+	return false;
+}
+
+// CHG 2012-08-16 huibong
+// 가변인자를 사용하는 Write 함수 다중 정의로 인해...
+// Complier 에서 인수 갯수 및 Type 이 동일할 경우 다른 함수를 가르키는 현상이 발견됨.
+// 이를 해결하기 위해 Write 함수에 대한 다중 정의를 제거토록 함수명을 명확하게 변경처리함.
+// 함수명 : Write -> WriteWithFunc 으로 변경 처리
+bool CLogger::WriteWithFunc( int logLevel, const char* filename, const char* funcname, int lineNum, const char * fmt, ...)
+{
+	if( filename == NULL || funcname == NULL || lineNum < 0 || fmt == NULL )
+	{
+		return false;
+	}
+
+	// 가변 인자 처리
+	va_list args;
+	char buffer[MAX_BUFFER_SIZE];
+	va_start( args, fmt );
+	if( vsnprintf( buffer, MAX_BUFFER_SIZE, fmt, args) < 0 )
+	{
+		va_end( args );
+		return false;
+	}
+	va_end(args);
+
+
+	char className[255]; 
+	string funcPrefix = GetClassName( className, filename );
+	funcPrefix += "::" + string( funcname ) + "()";
+
+	return Write( logLevel, PREFIX_FUNCTION, funcPrefix.c_str(), lineNum, buffer );
+}
+
+const char* CLogger::GetClassName( char* className,  const char* filename )
+{
+	if( className == NULL )
+	{
+		cout << "[ERROR] The input argument 'className' is NULL." << endl;
+		return NULL;
+	}
+
+	if( filename == NULL )
+	{
+		cout << "[ERROR] The input argument 'filename' is NULL." << endl;
+		strcpy( className, "NULL" );
+		return className;
+	}
+
+	int filenameSize = strlen( filename );
+	memcpy( className, filename, filenameSize ); 
+
+	// find end position
+	char endCharacter = '.';
+	int	 endPos		  = filenameSize - 1;
+	for( ; endPos > 0; --endPos )
+	{
+		if( className[endPos] == endCharacter )
+		{
+			break;
+		}
+	}
+
+	if( endPos == 0 )
+	{
+		cout << "[ERROR] endPos=0" << endl;
+		strcpy( className, "NULL" );
+		return className;
+	}
+
+	className[endPos] = '\0';
+
+	// find start position
+	char startCharacter = '/';
+	int  startPos		= endPos - 1;
+	for( ; startPos > 0; --startPos )
+	{
+		if( className[startPos] == startCharacter )
+		{
+			break;
+		}
+	}
+
+	if( startPos != 0 )
+	{
+		startPos += 1;
+	}
+
+	return (className + startPos );
+}
+
+bool CLogger::Write( int logLevel, int logPrefix, const char* functionName, int lineNum, const char* log )
+{
+	/// 유효한 로그 레벨이 아니면 로깅하지 않음.
+	if( IsValidLogLevel( logLevel ) == false )
+	{
+		return false;
+	}
+
+	// Log Level 검사 : 지정된 Level 이상인 경우 로깅하지 않음.
+	if( logLevel > m_nLogLevel )
+	{
+		return false;
+	}
+
+	if( log == NULL )
+	{
+		return false;
+	}
+
+	// Get Current Data & Time
+	time_t now = time( NULL );
+	struct tm timeNow;
+	localtime_r( &now, &timeNow );
+
+	string filename = GetLogFilename( timeNow );
+	
+	// Log file open
+	FILE* pFile = NULL;
+	pFile = fopen( filename.c_str(), "a+" );
+
+	if( pFile == NULL )
+	{
+		cerr << "Log file open fail.[" << filename.c_str() << "][" << errno << "][" << strerror(errno) << "]" << endl;
+		return false;
+	}
+
+	// 시간 정보처리
+	char timeStr[256];
+	snprintf( timeStr, (size_t)256, "[%02d:%02d:%02d]"
+			, timeNow.tm_hour, timeNow.tm_min, timeNow.tm_sec );
+
+	// Log Level 문자열 검색
+	string szLevel = m_vectorLogLevelString[ logLevel ];
+
+	switch( logPrefix )
+	{
+		case PREFIX_DATE:
+			/// 형식 예: [15:47:41] [DBG] sample log message.
+			fprintf( pFile, "%s [%-4s] %s\n", timeStr, szLevel.c_str(), log );
+			break;
+
+		case PREFIX_FUNCTION:
+			if( functionName == NULL )
+			{
+				fclose( pFile );
+				return false;
+			}
+			/// 형식 예: [15:47:41] [DBG] sample log message. [SomeClass::SomeFunction():12]
+			fprintf( pFile, "%s [%-4s] %s [%s:%d]\n", timeStr, szLevel.c_str(), log, functionName, lineNum );
+			break;
+
+		case PREFIX_NONE: 
+			/// 형식 예: sample log message.
+			fprintf( pFile, "%s\n", log );
+			break;
+	}
+	// Write to log file
+	fflush( pFile );
+
+	// 종료 처리.
+	fclose( pFile );
+	return true;
+}
+
+bool CLogger::WriteHex( int logLevel, const unsigned char* data, const int size )
+{
+	/// 유효한 로그 레벨이 아니면 로깅하지 않음.
+	if( IsValidLogLevel( logLevel ) == false )
+	{
+		return false;
+	}
+
+	// Log Level 검사 : 지정된 Level 이상인 경우 로깅하지 않음.
+	if( logLevel > m_nLogLevel )
+	{
+		return false;
+	}
+
+	if( data == NULL )
+	{
+		return false;
+	}
+
+	if( size <= 0 )
+	{
+		return false;
+	}
+
+	// Get Current Data & Time
+	time_t now = time( NULL );
+	struct tm timeNow;
+	localtime_r( &now, &timeNow );
+
+	string filename = GetLogFilename( timeNow );
+	
+	// Log file open
+	FILE* pFile = NULL;
+	pFile = fopen( filename.c_str(), "a+" );
+
+	if( pFile == NULL )
+	{
+		cerr << "Log file open fail.[" << filename.c_str() << "][" << errno << "][" << strerror(errno) << "]" << endl;
+		return false;
+	}
+
+	for( int i = 0; i < size; ++i )
+	{
+		fprintf( pFile, "%02X", data[i] );
+
+		if( i == 0 )
+		{
+			continue;
+		}
+
+		if( ( (i+1) % 8 ) == 0 )
+		{
+			fprintf( pFile, " " );
+		}
+
+		if( ( (i+1) % 16 ) == 0 )
+		{
+			fprintf( pFile, " " );
+		}
+
+		if( ( (i+1) % 32 ) == 0 )
+		{
+			fprintf( pFile, "\n" );
+		}
+	}
+	fprintf( pFile, "\n" );
+	fflush( pFile );
+
+	// 종료 처리.
+	fclose( pFile );
+
+	return false;
+}

fhs/csagentd/lib/Logger.h

@@ -0,0 +1,273 @@
+/***************************************************************************
+                Logger.h
+                -----------------------------------------
+    begin      : 2011/10/26
+    copyright  : (C) 2005 SolutionBox Inc.
+    author     : Service 1 Team
+    email      : svc1@solbox.com
+    version    : 3.2.0.805
+    
+    CopyRight(C) 2005 SolutionBox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+#ifndef __LOGGER_H__
+#define __LOGGER_H__
+
+#include <string>
+#include <vector>
+#include <pthread.h>
+
+///@brief  로그 레벨 정의
+#define LEMR		0	/* system is or will be unusable if situation is not resolved */
+#define LALT		1	/* immediate action required */
+#define LCRT		2	/* critical situations */
+#define LERR		3	/* error conditions */
+#define LWAR		4	/* recoverable errors */
+#define LNOT		5	/* unusual situation that merits investigation */
+#define LINF		6	/* information messages */
+#define LDBG		7	/* verbose data for debugging */
+#define LDEV		8	/* verbose data for developer */
+#define LDEV1		9	/* start or end the function of application level */
+#define LDEV2		10	/* start or end the function of application level */
+
+#define MAX_LOG_LEVEL LDEV2
+
+
+///@brief Log 정보를 파일로 저장하기 위한 Class.
+///1. 가변 format 으로 전달된 로그 관련 정보를 Log Level 에 따라 로그 파일에 아래의 4가지 형식으로 저장한다.
+///
+///   1.1 Prefix로 [hh:mm:ss]와 [ClassName::FunctionName]이 추가된 로그
+///       LOG( level, format, ... ) 매크로 사용.
+///       예) [17:43:40] [DBG] log level debug [LoggerTestTestLogger]
+///
+///   1.2 Prefix로 [hh:mm:ss]이 추가된 로그
+///       _LOG( level, format, ... ) 매크로 사용
+///       예) [17:43:40] [EMR] log level emergency
+///
+///   1.3 Prefix가 없는 로그
+///       _LOG_( level, format, ... ) 매크로 사용
+///       예) log level emergency
+///
+///   1.4 Hex 로그.
+///       LOG_HEX( level, data, size ) 매크로 사용
+///       예) 00010203 04050607  08090A0B 0C0D0E0F
+///
+///2. Logger 객체 초기화시 전달된 Log Level 정보보다 전달받은 Log Level 정보가 큰 경우 해당 로그는 파일로 저장되지 않는다.
+///
+///3. 로그 파일은 매 일단위로 저장파일이 변경된다.
+///
+///4. 로그 저장을 위한 program 경로가 존재하지 않는 경우 자동 생성 처리된다.
+///
+///5. 로그 저장방식은 매 저장로그마다 open-close 로 처리된다.
+///
+///6. 파일로 기록시 Log Level 에 대한 정보도 함께 기록된다.
+///
+///7. 싱글톤으로 작성되었고, CLogger::Init(...)시에 쓰레드 안정성을 제공한다.
+///
+///8. 동적으로 로그 레벨을 변경할 수 있는 인터페이스를 제공한다.
+///
+class CLogger
+{
+// Attributes
+private:
+	///@brief 싱글톤 객체 인트턴스.
+	static CLogger* m_pInstance;
+
+	///@brief 싱글톤 객체 초기화 여부.
+	static bool m_bIsInitialized;
+
+	///@brief 싱글톤 객체 초기화시 스레드 안정성을 위한 뮤텍스.
+	static pthread_mutex_t m_mutex;
+
+	///@brief 프로그램 이름. 로그 파일 경로를 만들 때 사용.
+	std::string m_szProgramName;
+
+	///@brief 공통 로그 디렉토리 이름. 로그 파일 경로를 만들 때 사용.
+	std::string m_szLogDir;
+
+	///@brief 로그 레벨.
+	int m_nLogLevel;
+
+	///@brief 로그 레벨에 대응되는 문자열 정보를 저장.
+	std::vector<std::string> m_vectorLogLevelString;
+
+protected:
+
+public:
+	///@brief 로그 형식을 지정.
+	typedef enum
+	{
+		PREFIX_NONE = 0,	/// 클래스 설명의 1.3에 해당
+		PREFIX_DATE,		/// 클래스 설명의 1.2에 해당
+		PREFIX_FUNCTION,	/// 클래스 설명의 1.1에 해당
+	} LOG_PREFIX;
+
+// Operations
+private:
+	///@brief 생성자.
+	///       프로그램 이름, 공통 로그 디렉토리, 로그 레벨을 저장하고 
+	///       로그 레벨에 대응되는 문자열 정보를 만든다.
+	///@param programName [in] 프로그램 이름
+	///@param logDir [in] 공통 로그 디렉토리 경로
+	///@param logLevel [in] 로그 레벨
+	CLogger( std::string programName, std::string logDir, int logLevel );
+
+	///@brief 소멸자.
+	///       로그 레벨에 대응되는 문자열 정보를 저장하고 있는 
+	///       벡터 m_vectorLogLevelString을 clear 시킴. 
+	virtual ~CLogger();
+
+	///@brief 로그 레벨에 대응되는 문자열을 만든다.
+	///@param none.
+	///@return none.
+	void MakeLogLevelString();
+
+	///@brief 로그 파일이 위치할 실제 로그 디렉토리를 생성한다.
+	///       생성할 디렉토리 경로는 'logDir/programName'이 된다.
+	///@param programName [in]  프로그램 이름 
+	///@param logDir [in] 공통 로그 디렉토리 경로
+	///@return  디렉토리가 이미 존재하거나 생성 성공하면 true, 
+	///         해당 경로가 존재하지만 디렉토리가 아니거나, 디렉토리 생성 실패하면 false 반환.
+	static bool MakeLogDir( std::string programName, std::string logDir );
+
+	///@brief 해당 경로가 디렉토리 인지 아닌지 판단.
+	///@param path [in] 디렉토리 인지 아닌지 판단할 경로.
+	///@return 해당 경로가 디렉토이면 true,
+	///        경로가 존재하지 않거나 디렉토리가 아니면 false 반환.
+	static bool IsDirectory( std::string path );
+
+	///@brief 로그 레벨이 올바른지 판별.
+	///@param logLevel [in]
+	///@return 올바른 로그 레벨이면 true, 그렇지 않으면 false 반환.
+	static bool IsValidLogLevel( int logLevel );
+
+	///@brief 시간 정보를 입력 받아 로그 파일 이름을 만든다.
+	///       로그 파일 이름 형식 : 프로그램명_YYYYMMDD.log
+	///param timeNow [in] 현재 시간 정보.
+	///return 로그 파일 이름.
+	std::string GetLogFilename( struct tm &timeNow );
+
+	///@brief 로그를 남기는는 클래스가 정의된 파일의 이름에서 클래스명을 추출한다.
+	///       쓰레드 안정성을 보장한다.
+	///@param className [out] 파일 이름에서 추출된 클래스명
+	///@param filename [in] 파일 이름.
+	///@return 클래스명 추출이 성공하면 클래스명 문자열의 포인터, 추출 실패하면 NULL.
+	const char* GetClassName( char* className, const char* filename );
+
+	///@brief 인자 logPrefix에 따라 적절한 형식으로 로그 파일에 로그를 저장한다.
+	///       인자 logLevel이 설정된 로그 레벨보다 높으면 로그를 출력하지 않는다. 
+	///@param logLevel [in] 로그 레벨
+	///@param logPrefix [in] 로그 프리픽스 종류.
+	///@functionName [in] ClassName::FunctionNmae() 형식의 문자열.
+	///@lineNum [in] 라인 번호.
+	///@log [in] 출력하고자 하는 로그 내용.
+	bool Write( int logLevel, int logPrefix, const char* functionName, int lineNum, const char* log );
+
+protected:
+
+public:
+	///@brief 싱글톤 객체 m_pInstance를 생성하고 인자 정보로 로그 디렉토리를 만든다.
+	///@param programName [in] 프로그램 이름
+	///@param logDir [in] 공통 로그 디렉토리 경로
+	///@param logLevel [in] 로그 레벨
+	///@return 로그 디렉토리를 만들고 싱글톤 객체를 생성했으면 true,
+	///        로그 디렉토리를 만들지 못 했거나 인자 값이 올바르지 않으면 false 반환.
+	static bool Init( std::string programName, std::string logDir, int logLevel );
+
+	///@brief 싱글톤 객체 m_pInstance를 delete 한다.
+	///@param none.
+	///@return none.
+	static void Exit();
+
+	///@brief 싱글톤 객체 m_pInstance를 반환한다.
+	///@param none.
+	///@return CLogger 객체의 인스턴스.
+	static CLogger* GetInstance();
+
+	///@brief Prefix로 [hh:mm:ss]이 추가된 형식으로 로그 저장.
+	///@param logLevel [in] 로그 레벨
+	///@param fmt [in] 로그 내용 포맷.
+	///@param __VAR_ARGS__ [in] 가변 인자.
+	///@return 로그 파일에 로그를 저장했으면 true, 그렇지 않으면 false 반환
+	bool Write( int logLevel, const char * fmt, ...)
+	    __attribute__((format(printf, 3, 4)));
+
+	///@brief Prefix가 없는 로그 저장.
+	///@param logLevel [in] 로그 레벨
+	///@param fmt [in] 로그 내용 포맷.
+	///@param __VAR_ARGS__ [in] 가변 인자.
+	///@return 로그 파일에 로그를 저장했으면 true, 그렇지 않으면 false 반환
+	bool WriteNoPrefix( int logLevel, const char * fmt, ...)
+	    __attribute__((format(printf, 3, 4)));
+
+
+	// CHG 2012-08-16 huibong
+	// 가변인자를 사용하는 Write 함수 다중 정의로 인해...
+	// Complier 에서 인수 갯수 및 Type 이 동일할 경우 다른 함수를 가르키는 현상이 발견됨.
+	// 이를 해결하기 위해 Write 함수에 대한 다중 정의를 제거토록 함수명을 명확하게 변경처리함.
+
+	///@brief Prefix로 [hh:mm:ss]와 [ClassName::FunctionName:line]이 추가된 형식으로 로그 저장.
+	///@param logLevel [in] 로그 레벨
+	///@param filename [in] 파일 이름
+	///@param funcname [in] 함수 이름
+	///@param lineNum [in] 라인 번호
+	///@param fmt [in] 로그 내용 포맷.
+	///@param __VAR_ARGS__ [in] 가변 인자.
+	///@return 로그 파일에 로그를 저장했으면 true, 그렇지 않으면 false 반환
+	bool WriteWithFunc( int logLevel, const char* filename, const char* funcname, int lineNum, const char * fmt, ...)
+	     __attribute__((format(printf, 6, 7)));
+
+	///@brief 로그를 hex 형식으로 저장.
+	///@param logLevel [in] 로그 레벨
+	///@param data [in] hex 형식으로 출력할 데이터.
+	///@pram size [in] data의 크기.
+	///@return 로그 파일에 로그를 저장했으면 true, 그렇지 않으면 false 반환
+	bool WriteHex( int logLevel, const unsigned char* data, const int size );
+
+	///@brief 로그을 설정한다. 인자 logLevel이 적절한 값이면 새로운 값으로 변경하고
+	///       적절한 값이 아니면 로그 레벨을 변경하지 않는다.
+	///@param logLevel [in] 설정할 로그 레벨
+	///@return none.
+	bool SetLogLevel( int logLevel );
+
+	inline int GetLogLevel() { return m_nLogLevel; };
+	inline std::string GetLogDir() { return m_szLogDir + "/" + m_szProgramName; };
+};
+
+#define LOG( level, format, ... ) \
+	if( CLogger::GetInstance() != NULL ) \
+	{ \
+		CLogger::GetInstance()->WriteWithFunc( level, __FILE__, __FUNCTION__, __LINE__, format, ##__VA_ARGS__ ); \
+	}
+	
+
+#define _LOG( level, format, ... ) \
+	if( CLogger::GetInstance() != NULL ) \
+	{ \
+		CLogger::GetInstance()->Write( level, format, ##__VA_ARGS__ ); \
+	}
+	
+
+#define _LOG_( level, format, ... ) \
+	if( CLogger::GetInstance() != NULL ) \
+	{ \
+		CLogger::GetInstance()->WriteNoPrefix( level, format, ##__VA_ARGS__ ); \
+	}
+	
+
+#define _LOG_HEX_( level, data, size ) \
+	if( CLogger::GetInstance() != NULL ) \
+	{ \
+		CLogger::GetInstance()->WriteHex( level, (const unsigned char*)data, size ); \
+	}
+
+
+
+#define FUNC_BEGIN() LOG( LDEV1, "begin" )
+#define FUNC_END() LOG( LDEV1, "end" )
+
+#define FRM_BEGIN() LOG( LDEV2, "begin" )
+#define FRM_END() LOG( LDEV2, "end" )
+
+#endif // __LOGGER_H__

fhs/csagentd/lib/Makefile

@@ -0,0 +1,61 @@
+#****************************************************************************
+#                Makefile for Cloud Storage Common Libaray
+#                -----------------------------------------
+#
+#    begin      : 2015/04/13
+#    copyright  : (C) 2013 Solbox Inc.
+#    author     : Dev Storage Team
+#    email      : storage.sd@solbox.com
+#    version    : 3.5.0
+#
+#    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+#    Redistribution and use in source and binary forms, with or with out
+#    modification, are not permitted in outside of Solbox Inc.
+#*****************************************************************************
+
+# Library info
+
+LIB_NAME = InterCommon
+
+LIB = lib$(LIB_NAME).a
+
+OBJS = Config.o Logger.o BaseSocket.o 
+
+# Compiler info
+CC     = /usr/bin/g++
+AR     = /usr/bin/ar
+
+DIR_INCLUDE = -I/usr/local/include 
+
+CFLAGS = -Wall -O3 -g -Wreturn-type -Wunused -Wuninitialized\
+		 -Wparentheses -Wshadow -Wpointer-arith -Woverloaded-virtual\
+		 -D_REENTRANT -D_THREAD_SAFE -D_PTHREADS
+
+
+############################
+
+all:$(LIB)
+	sync
+
+%.o: %.cpp
+	$(CC) $(CFLAGS) -o $@ -c $^ $(DIR_INCLUDE)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ -c $^ $(DIR_INCLUDE) 
+
+
+$(LIB): $(OBJS)
+	$(AR) crsv $@ $^
+
+
+clean:
+	-rm -f *.o core *.out *.log
+	-rm -f $(LIB)
+	sync
+
+
+install : 
+	sync
+
+
+# End of Makefile