smartservice_native/ed780/hdtermd.cpp

#ifdef _WIN32

#define _CRT_SECURE_NO_WARNINGS

#include <winsock2.h>
#include <ws2tcpip.h>
#include <io.h>
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "winmm.lib")

#else

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>	// sockaddr_in
#include <arpa/inet.h>	// inet_ntoa()
#include <unistd.h>	// close()
#include <netdb.h>	// gethostbyname()
#include <fcntl.h>	// F_GETFL, O_NONBLOCK
#include <netinet/tcp.h>	// TCP_NODELAY
#include <string.h>
#include <errno.h>
#include <time.h>
//#include <pthread.h>
#include <stdarg.h>


typedef int BOOL;
#define TRUE 1
#define FALSE 0

#define INVALID_SOCKET  (SOCKET)(~0)
#define SOCKET_ERROR            (-1)

#define SD_RECEIVE		SHUT_RD
#define SD_SEND			SHUT_WR
#define SD_BOTH			SHUT_RDWR

typedef int SOCKET;

#define closesocket		close


inline unsigned int timeGetTime()
{
#if 0
    struct timeval tv;
    gettimeofday(&tv, NULL);	// obsolescent at 2008

    return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
#else
	//struct timespec ts;	
	//clock_gettime(CLOCK_MONOTONIC, &ts);

	//return (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
	struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);

    uint64_t ms = (uint64_t)ts.tv_sec * 1000ULL +
                  (uint64_t)ts.tv_nsec / 1000000ULL;

    return (unsigned int)ms;   // 32bit wrap intentionally
#endif
}
#define GetTickCount timeGetTime

inline void Sleep(unsigned int nTime)
{
#if 0
	struct timeval tv;

	tv.tv_sec = nTime / 1000;
	tv.tv_usec = (nTime % 1000) * 1000;	// msec

	select(0, NULL, NULL, NULL, &tv);
#else
	struct timespec ts;

	ts.tv_sec = nTime / 1000;
	ts.tv_nsec = (nTime % 1000) * 1000000;	// nsec

	nanosleep(&ts, NULL);
#endif
}


#endif

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include <sys/stat.h>

#ifdef _DEBUG
#include <crtdbg.h>
#endif

#include <list>


//////////////////////////////////////////////////////////////////////////////

inline int GetSockError()
{
#ifdef _WIN32
	return WSAGetLastError();
#else
	return errno;
#endif
}

int GetSockOptError(SOCKET sock)
{
	int nOptVal;
	socklen_t nOptLen = sizeof(int);
	if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)(&nOptVal), &nOptLen) < 0)
		return GetSockError();

	return nOptVal;
}

#ifdef _WIN32
VOID WINAPI FlsBufferFree(PVOID lpFlsData)
{
    if (lpFlsData != NULL)
	{
		fprintf(stdout, "DEBUG, FlsBufferFree, lpFlsData = 0x%p\n", lpFlsData);
        LocalFree(lpFlsData);
    }
}

char * GetLocalStorageBuffer(DWORD nFlsIdx, size_t nSize)
{
	char * pszBuffer = (char *)FlsGetValue(nFlsIdx);
	if (pszBuffer == NULL)
	{
        pszBuffer = (char *)LocalAlloc(LPTR, nSize);
        if (pszBuffer == NULL) 
			return NULL;
        
        FlsSetValue(nFlsIdx, pszBuffer);
    }

	return pszBuffer;
}
#endif


const char * GetErrorStr(int nError)
{
#ifdef _WIN32
	static DWORD nFlsIdx = FLS_OUT_OF_INDEXES;
	if (nFlsIdx == FLS_OUT_OF_INDEXES)
		nFlsIdx = FlsAlloc(FlsBufferFree);

	char * pszBuffer = (char *)GetLocalStorageBuffer(nFlsIdx, 512);
	if (pszBuffer == NULL)
        return "[SystemError], Failed to LocalAlloc";

    if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, 
		nError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), pszBuffer, 512, NULL) == 0)
	{
		sprintf(pszBuffer, "Unknown Error", nError);
	}

    return pszBuffer;
#else
	return strerror(nError);
#endif
}

inline unsigned int TimeDiff(unsigned int nTimePrev, unsigned int nTimeCurr)
{
	if (nTimePrev <= nTimeCurr)
		return nTimeCurr - nTimePrev;

	return nTimeCurr + (0xFFFFFFFFU - nTimePrev) + 1U;
}

// file //////////////////////////////////////////////////////////////////////
class CtFile
{
public:
	enum
	{
		FMODE_CREATE = 0x0001,
		FMODE_RDONLY = 0x0002,
		FMODE_WRONLY = 0x0004,
		FMODE_RW = 0x0008
	};

	static off_t GetSize(const char * pszFileName)
	{
		struct stat statTemp;
		stat(pszFileName, &statTemp);

		return statTemp.st_size;
	}

	////

	CtFile()
	{
		m_nFile = -1;
	}

	~CtFile()
	{
		Close();
	}

	int GetFile() { return m_nFile; }

	bool Open(const char * pszFileName, int nMode, bool bIsBinary = true, bool bIsContinue = true)
	{
		int oflag = 0;

		if ((nMode & FMODE_CREATE) == FMODE_CREATE)
			oflag = O_CREAT;

		if ((nMode & FMODE_RDONLY) == FMODE_RDONLY)
			oflag |= O_RDONLY;
		else if ((nMode & FMODE_WRONLY) == FMODE_WRONLY)
			oflag |= O_WRONLY;
		else 
			oflag |= O_RDWR;

		if (bIsContinue == FALSE && ((nMode & FMODE_WRONLY) == FMODE_WRONLY || (nMode & FMODE_RW) == FMODE_RW))
			oflag |= O_TRUNC;

#ifdef _WIN32
		if (bIsBinary)
			oflag |= O_BINARY;
		else
			oflag |= O_TEXT;

		m_nFile = open(pszFileName, oflag, S_IREAD | S_IWRITE);
#else
		m_nFile = open(pszFileName, oflag, S_IREAD | S_IWRITE | S_IRGRP | S_IROTH);
#endif

		if (m_nFile == -1)
			return false;

		if (bIsContinue && ((nMode & FMODE_WRONLY) == FMODE_WRONLY || (nMode & FMODE_RW) == FMODE_RW))
			lseek(m_nFile, 0L, SEEK_END);

		return true;
	}

	void Close()
	{
		if (m_nFile != -1)
		{
			close(m_nFile);
			m_nFile = -1;
		}
	}
	
	int Read(void * buffer, unsigned int count)
	{
		return read(m_nFile, buffer, count);
	}

	int Write(const void * buffer, unsigned int count)
	{
		return write(m_nFile, buffer, count);
	}

private:
	int m_nFile;
};
//////////////////////////////////////////////////////////////////////////////


class IompObject
{
public:
	enum {
		IOMP_DISABLE = 0,
		IOMP_READY = 1,
		IOMP_CONNECTING = 2,
		IOMP_RECONNECTING = 3,
		IOMP_LISTENING = 4,
		IOMP_CLOSING = 5,
		IOMP_REMOVE = 6
	};

	SOCKET m_sock;
	int m_nState;
	struct sockaddr_in m_sai;	// remote or listen
	unsigned int m_nPrevTick;	// prev setted time
	unsigned int m_nConnectTimeOut;	// for connect timeout
	unsigned int m_nAutoReconnectInterval;	// 0: no reconnect, 1~ : msec, reconnect interval time


	IompObject()
	{
		m_nState = IOMP_DISABLE;
		memset(&m_sai, 0, sizeof(struct sockaddr_in));	// remote or listen
		m_nPrevTick = 0;
		m_nConnectTimeOut = 0;
		m_nAutoReconnectInterval = 0;
	}

	int Create()
	{
		// create socket
		m_sock = socket(AF_INET, SOCK_STREAM, 0);
		if (m_sock == INVALID_SOCKET)
		{
			fprintf(stderr, "[ERROR], Failed to socket()\n");
			return -1;
		}

	// Set non blocking mode
#ifdef _WIN32
		ULONG nNonBlock = 1;
		if (ioctlsocket(m_sock, FIONBIO, &nNonBlock) == SOCKET_ERROR)
#else
		int nFlags = fcntl(m_sock, F_GETFL, 0);
		if (fcntl(m_sock, F_SETFL, nFlags | O_NONBLOCK) == -1)
#endif
		{
			int nSockError = GetSockError();
			fprintf(stderr, "[ERROR], Failed to ioctlsocket. socket = %d, error = %s(%d)\n", m_sock, GetErrorStr(nSockError), nSockError);
			closesocket(m_sock);
			return -1;
		}
	    
		int nBuffSize = 1024 * 1024 * 4;	// 4Mbyte
		if (setsockopt(m_sock, SOL_SOCKET, SO_SNDBUF, (const char *)&nBuffSize, sizeof(nBuffSize)) == SOCKET_ERROR)
			fprintf(stderr, "[WARN], Failed to setsockopt SO_SNDBUF, socket = %d\n", m_sock);

		if (setsockopt(m_sock, SOL_SOCKET, SO_RCVBUF, (const char *)&nBuffSize, sizeof(nBuffSize)) == SOCKET_ERROR)
			fprintf(stderr, "[WARN], Failed to setsockopt SO_RCVBUF, socket = %d\n", m_sock);

		return 0;
	}

	int Bind(const char * pszIp, unsigned short nPort)
	{
#define REUSEADDR_
#ifdef REUSEADDR_
		int nOptVal = 1;
		setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&nOptVal, sizeof(nOptVal));	// for multiple ip in UNIX
#endif
		if (pszIp == NULL || pszIp[0] == '\0')
			m_sai.sin_addr.s_addr = htonl(INADDR_ANY);
		else
			m_sai.sin_addr.s_addr = inet_addr(pszIp);

		m_sai.sin_family = AF_INET;
		m_sai.sin_port = htons(nPort);

		if (bind(m_sock, (struct sockaddr *)&m_sai, sizeof(struct sockaddr)) == -1)
		{
			int nSockError = GetSockError();
			fprintf(stderr, "[ERROR], Failed to bind.(%s:%d) socket = %d, error = %s(%d)\n", inet_ntoa(m_sai.sin_addr), ntohs(m_sai.sin_port), 
				m_sock, GetErrorStr(nSockError), nSockError);
			closesocket(m_sock);
			return -1;
		}
		fprintf(stdout, "INFO, Succeeded to bind.(%s:%d), socket = %d\n", inet_ntoa(m_sai.sin_addr), ntohs(m_sai.sin_port), m_sock);	// listen ip:port

		return 0;
	}

	int Listen(int nBackLog)
	{
		if (listen(m_sock, nBackLog) == -1)
		{
			int nSockError = GetSockError();
			fprintf(stderr, "[ERROR], Failed to listen. socket = %d, error = %s(%d)\n", m_sock, GetErrorStr(nSockError), nSockError);
			closesocket(m_sock);
			return -1;
		}
		fprintf(stdout, "INFO, Succeeded to listen.(%s:%d), socket = %d\n", inet_ntoa(m_sai.sin_addr), ntohs(m_sai.sin_port), m_sock);	// listen ip:port

		m_nState = IOMP_LISTENING;
		return 0;
	}

	int ConnectProc(unsigned int nCurrTick)
	{
		int nResult = connect(m_sock, (struct sockaddr *)&m_sai, sizeof(struct sockaddr));
		
	#ifdef _WIN32
		if (nResult == SOCKET_ERROR && GetSockError() != WSAEWOULDBLOCK)
	#else
		if (nResult == SOCKET_ERROR && errno != EWOULDBLOCK && errno != EINPROGRESS)
	#endif
		{
			int nSockError = GetSockError();
			fprintf(stderr, "[ERROR], Failed to connect. socket = %d, error = %s(%d)\n", m_sock, GetErrorStr(nSockError), nSockError);
			closesocket(m_sock);
			m_sock = INVALID_SOCKET;
			return -1;
		}

		m_nPrevTick = nCurrTick;
		m_nState = IOMP_CONNECTING;
		fprintf(stdout, "INFO, TCP connecting... to %s:%d, socket = %d\n", inet_ntoa(m_sai.sin_addr), ntohs(m_sai.sin_port), m_sock);

		return 0;
	}

	int Connect(const char * pszIp, unsigned short nPort, unsigned int nTimeout, unsigned int nCurrTick = 0, unsigned int nAutoReconnectInterval = 0)
	{
		if (m_sock == INVALID_SOCKET)
		{
			fprintf(stderr, "[ERROR], This socket did not created.\n");
			return -1;
		}

		m_sai.sin_addr.s_addr = inet_addr(pszIp);
		m_sai.sin_family = AF_INET;
		m_sai.sin_port = htons(nPort);

		m_nConnectTimeOut = nTimeout;
		m_nAutoReconnectInterval = nAutoReconnectInterval;

		return ConnectProc(nCurrTick);
	}

	int Disconnect()
	{
		return shutdown(m_sock, SD_SEND);
	}

	bool IsConnectTimeout(unsigned int nCurrTick)
	{
		//fprintf(stdout, "DEBUG, m_nPrevTick = %d, nCurrTick = %d\n", m_nPrevTick, nCurrTick);

		if (m_nPrevTick == 0)
		{
			m_nPrevTick = nCurrTick;
			return false;
		}
		
		if (m_nConnectTimeOut <= 0)
			return false;

		if (m_nConnectTimeOut <= TimeDiff(m_nPrevTick, nCurrTick))
			return true;

		return false;
	}

	int TcpCompleteSend(const char * pPacket, int nPacketSize)
	{
		off_t nSentSize;
		const char * pszPacketOffset = pPacket;
		while (nPacketSize > 0)
		{
			nSentSize = send(m_sock, pszPacketOffset, nPacketSize, 0);
			if (nSentSize <= 0)
			{
				int nSockError = GetSockError();
				fprintf(stderr, "[ERROR], Failed to send, sock = %d, error = %s(%d)\n", m_sock, GetErrorStr(nSockError), nSockError);
				return -1;
			}

			nPacketSize -= nSentSize;
			pszPacketOffset += nSentSize;
		}

		return 0;
	}

	int Receive(char * pBuffer, int nMaxSize)
	{
		int nReceived = recv(m_sock, pBuffer, nMaxSize, 0);
		if (nReceived == -1)
		{
			int nSockError = GetSockError();
			fprintf(stdout, "INFO, The virtual circuit was reset by the remote side executing a \"hard\" or \"abortive\" close, socket = %d, error = %s(%d)\n", m_sock, GetErrorStr(nSockError), nSockError);
			shutdown(m_sock, SD_BOTH);
			return -1;
		}
		else if (nReceived == 0)
		{
			fprintf(stdout, "INFO, The virtual circuit was reset by the remote side executing a \"gracefull\" shutdown, socket = %d\n", m_sock);
			shutdown(m_sock, SD_SEND);
			return -1;
		}	

		return nReceived;
	}
};

template<class _T>
class IompDispatcher
{
public:
	IompDispatcher()
	{
		//m_nDispachInterval = 500;	//msec, set timer
		//m_nDispachInterval = 200;	//msec, set timer
		m_nDispachInterval = 0;	//msec, set timer
		m_bTerminate = false;
	}

	virtual ~IompDispatcher()
	{
	}

	_T * AddSocket(_T & t)
	{
		m_listIomp.push_front(t);
		return &m_listIomp.front();
	}

	int Dispatch()
	{
		fprintf(stdout, "INFO, IompDispatcher.Dispatch() started.\n");

		fd_set fsRead, fsWrite, fsError;
		int nSelectResult, nFdMax, nFdCount;
		typename std::list<_T>::iterator iter;
		struct timeval tvWait;
		unsigned int nCurrTick = 0, nPrevTimerTick = 0;

		while (m_bTerminate == false)
		{
//#define TEST_TERMINATE_
#ifdef TEST_TERMINATE_		//TestCode
			//static int nTestCount = 2000;
			static int nTestCount = 1000;
			if (nTestCount-- < 0)
				break;
#endif
			nCurrTick = GetTickCount();

			if (m_nDispachInterval > 0 && m_nDispachInterval <= TimeDiff(nPrevTimerTick, nCurrTick))
			{
				OnDispatchTimer(nCurrTick);
				nPrevTimerTick = nCurrTick;
			}

			FD_ZERO(&fsRead);
			FD_ZERO(&fsWrite);
			FD_ZERO(&fsError);

			nFdMax = 0;
			nFdCount = 0;

			for (iter = m_listIomp.begin(); iter != m_listIomp.end(); iter++)
			{
				if (iter->m_nState == IompObject::IOMP_REMOVE)
				{
					OnIompDelete(&*iter, nCurrTick);
					iter = m_listIomp.erase(iter);
					if (m_listIomp.empty() || iter == m_listIomp.end())
						break;
				}
				else if (iter->m_nState == IompObject::IOMP_CLOSING)
				{
					int nResult = OnIompClose(&*iter, nCurrTick);
					iter->m_nPrevTick = nCurrTick;
					closesocket(iter->m_sock);

					if (iter->m_nAutoReconnectInterval > 0)
					{
						iter->m_sock = INVALID_SOCKET;
						iter->m_nState = IompObject::IOMP_RECONNECTING;
					}
					else if (nResult == 0)
					{
						iter->m_nState = IompObject::IOMP_REMOVE;
					}
					else
					{
						iter->m_sock = INVALID_SOCKET;
						iter->m_nState = IompObject::IOMP_DISABLE;
					}
				}
				else if (iter->m_nState == IompObject::IOMP_RECONNECTING)
				{
					if (iter->m_nAutoReconnectInterval <= TimeDiff(iter->m_nPrevTick, nCurrTick))
					{
						if ((iter->Create()) == -1)
							iter->m_nState = IompObject::IOMP_REMOVE;
						else if (iter->ConnectProc(nCurrTick) == -1)
							iter->m_nState = IompObject::IOMP_REMOVE;
					}
				}
				else if (iter->m_nState == IompObject::IOMP_READY || iter->m_nState == IompObject::IOMP_LISTENING)
				{
					if (iter->m_nState == INVALID_SOCKET)
						fprintf(stderr, "[ERROR_DEBUG], Invalid logic. socket = %d\n", iter->m_nState, iter->m_sock);

					FD_SET(iter->m_sock, &fsRead);
					//FD_SET(iter->m_sock, &fsError);
					nFdCount++;
#ifndef _WIN32
					if (nFdMax < iter->m_sock)
						nFdMax = iter->m_sock;
#endif
				}
				else if (iter->m_nState == IompObject::IOMP_CONNECTING)
				{
					if (iter->IsConnectTimeout(nCurrTick))
					{
						fprintf(stdout, "[WARN], Failed to connect because of timeout. socket = %d\n", iter->m_sock);
						OnIompConnect(&*iter, false, nCurrTick);
						shutdown(iter->m_sock, SD_BOTH);
						iter->m_nState = IompObject::IOMP_CLOSING;
					}
					else
					{
						if (iter->m_nState == INVALID_SOCKET)
							fprintf(stderr, "[ERROR_DEBUG], Invalid logic. socket = %d\n", iter->m_nState, iter->m_sock);

						FD_SET(iter->m_sock, &fsWrite);
						nFdCount++;
#ifndef _WIN32
						if (nFdMax < iter->m_sock)
							nFdMax = iter->m_sock;
#endif
					}
				}

#if 0	// send buffer version
				if (iter->m_nState != IompObject::IOMP_DISABLE && iter->m_nState != IompObject::IOMP_CLOSING &&	iter->m_nState != IompObject::IOMP_REMOVE &&
					pSocket->GetSendBuffer()->empty() == false)
				{
					if (iter->m_nState == INVALID_SOCKET)
						fprintf(stderr, "[ERROR_DEBUG], Invalid logic. socket = %d\n", iter->m_nState, iter->m_sock);

					FD_SET(iter->m_sock, &fsWrite);
					nFdCount++;
#ifndef _WIN32
					if (nFdMax < iter->m_sock)
						nFdMax = iter->m_sock;
#endif
				}
#endif
			}

			if (m_listIomp.empty() || nFdCount == 0)
			{
				Sleep(5);
				continue;
			}
//#define TEST_INTERVAL_
#ifdef TEST_INTERVAL_
			tvWait.tv_sec = 3;	//TestCode
			tvWait.tv_usec = 0;
#else
			tvWait.tv_sec = 0;
			tvWait.tv_usec = 50000;	// 50 msec
#endif
			//nSelectResult = select(nFdMax + 1, &fsRead, &fsWrite, &fsError, &tvWait);
			nSelectResult = select(nFdMax + 1, &fsRead, &fsWrite, NULL, &tvWait);
			//fprintf(stdout, "DEBUG, nSelectResult = %d\n", nSelectResult);

			if (nSelectResult == 0)
			{
				continue;	// timeout
			}
			else if (nSelectResult == -1)
			{
				int nSockError = GetSockError();
				fprintf(stdout, "[WARN], Failed to select. error = %s(%d)\n", GetErrorStr(nSockError), nSockError);
				Sleep(5);
				continue;
			}

			for (iter = m_listIomp.begin(); iter != m_listIomp.end(); iter++)
			{
				if (iter->m_sock == INVALID_SOCKET ||
					iter->m_nState == IompObject::IOMP_DISABLE || iter->m_nState == IompObject::IOMP_CLOSING ||	iter->m_nState == IompObject::IOMP_REMOVE)
					continue;

				if (FD_ISSET(iter->m_sock, &fsRead) != 0)
				{
					if (iter->m_nState == IompObject::IOMP_LISTENING)
					{					
						_T iompSocket;

						socklen_t len = sizeof(struct sockaddr);
						if ((iompSocket.m_sock = accept(iter->m_sock, (struct sockaddr *)&iompSocket.m_sai, &len)) == INVALID_SOCKET)
						{
							int nSockError = GetSockError();
							fprintf(stderr, "[ERROR], Failed to accept. socket = %d, error = %s(%d)\n", iter->m_sock, GetErrorStr(nSockError), nSockError);
						}
						else
						{
							fprintf(stdout, "INFO, Succeeded to accept.(%s:%d), socket = %d\n", inet_ntoa(iter->m_sai.sin_addr), ntohs(iter->m_sai.sin_port), iter->m_sock);	// listen ip:port
							fprintf(stdout, "INFO, Accepted src address (%s:%d), socket = %d\n", inet_ntoa(iompSocket.m_sai.sin_addr), ntohs(iompSocket.m_sai.sin_port), iompSocket.m_sock);	// remote ip:port
							
							if (OnIompAccept(&iompSocket, nCurrTick) != -1)
							{
								// Set non blocking mode
#ifdef _WIN32
								ULONG nNonBlock = 1;
								if (ioctlsocket(iompSocket.m_sock, FIONBIO, &nNonBlock) == SOCKET_ERROR)
#else
								int nFlags = fcntl(iompSocket.m_sock, F_GETFL, 0);
								if (fcntl(iompSocket.m_sock, F_SETFL, nFlags | O_NONBLOCK) == -1)
#endif
								{
									int nSockError = GetSockError();
									fprintf(stderr, "[ERROR], Failed to ioctlsocket. socket = %d, error = %s(%d)\n", iompSocket.m_sock, GetErrorStr(nSockError), nSockError);
									closesocket(iompSocket.m_sock);
								}
								else
								{
									iompSocket.m_nState = IompObject::IOMP_READY;
									iompSocket.m_nPrevTick = nCurrTick;
									m_listIomp.push_front(iompSocket);
								}
							}
							else
							{
								closesocket(iompSocket.m_sock);
							}
						}
					}
					else if (iter->m_nState == IompObject::IOMP_READY)
					{
						if (OnIompReceive(&*iter, nCurrTick) == -1)
						{
							shutdown(iter->m_sock, SD_SEND);
							iter->m_nState = IompObject::IOMP_CLOSING;
						}
						
						iter->m_nPrevTick = nCurrTick;
					}

					FD_CLR(iter->m_sock, &fsRead);

					if (--nSelectResult <= 0)
						break;
				}

				if (FD_ISSET(iter->m_sock, &fsWrite) != 0)
				{
					if (iter->m_nState == IompObject::IOMP_CONNECTING)
					{
						int nSocketOptError = GetSockOptError(iter->m_sock);
						if (nSocketOptError != 0)
						{
							fprintf(stderr, "[ERROR], Failed to connect.(%s:%d) socket = %d, error = %s(%d)\n",
								inet_ntoa(iter->m_sai.sin_addr), ntohs(iter->m_sai.sin_port), iter->m_sock, GetErrorStr(nSocketOptError), nSocketOptError);
							OnIompConnect(&*iter, false, nCurrTick);
							shutdown(iter->m_sock, SD_BOTH);
							iter->m_nState = IompObject::IOMP_CLOSING;
						}
						else
						{
							fprintf(stdout, "INFO, Succeeded to connect.(%s:%d) socket = %d\n", 
						 		inet_ntoa(iter->m_sai.sin_addr), ntohs(iter->m_sai.sin_port), iter->m_sock);
							OnIompConnect(&*iter, true, nCurrTick);
							iter->m_nState = IompObject::IOMP_READY;
						}
						iter->m_nPrevTick = nCurrTick;
					}
					//else if (iter->m_nState == IompObject::IOMP_READY)
					//{
					//	if (pSocket->OnSendRetry() < 0)	// remain packet send
					//	{
					//		HLOGF(15, "[TRACE], MpsDisp, Failed to OnSendRetry socket = %d\n", pSocket->GetSocket());
					//		pSocket->FinishTcp();
					//	}
					//}

					FD_CLR(iter->m_sock, &fsWrite);

					if (--nSelectResult <= 0)
						break;
				}
			}
		}

		return false;
	}

protected:
	virtual int OnIompConnect(_T * pIomp, bool bIsSuccess, unsigned int nCurrTick) { return 0; }
	virtual int OnIompReceive(_T * pIomp, unsigned int nCurrTick) { return 0; }
	virtual int OnIompAccept(_T * pIomp, unsigned int nCurrTick) { return 0; }
	virtual int OnIompClose(_T * pIomp, unsigned int nCurrTick) { return 0; }
	virtual int OnIompDelete(_T * pIomp, unsigned int nCurrTick) { return 0; }
	virtual void OnDispatchTimer(unsigned int nCurrTick) {}

protected:
	unsigned int m_nDispachInterval;	//msec
	bool m_bTerminate;
	std::list<_T> m_listIomp;
};
//////////////////////////////////////////////////////////////////////////////

void get_crc(unsigned char* data, int length, unsigned short* crc)
{
	int i;
	//unsigned temp;
	unsigned short temp;
	unsigned short SEED = 0x8005;
	*crc = 0xffff;
	do {
		temp = *data++ & 0xff;
		for (i = 0; i < 8; i++) {
			if ((*crc & 0x0001) ^ (temp & 0x01))
				*crc = (*crc >> 1) ^ SEED;
			else
				*crc >>= 1;
			temp >>= 1;
		}
	} while (--length);
	*crc = ~*crc;
	temp = *crc;
	*crc = (*crc << 8) | ((temp >> 8) & 0xff);
	return;
}

int SendToKicc(IompObject * pIomp, unsigned short cmd, const char * pData, size_t nDataSize)
{
	volatile unsigned char pPacket[8192];
	memset((void *)pPacket, 0, 8192);

	volatile unsigned char * ptr = pPacket;
	*ptr++ = 0x02;

	volatile unsigned char * LEN = ptr;
	unsigned short nLen = htons(6 + nDataSize);
	memcpy((void *)ptr, (void *)&nLen, sizeof(unsigned short));

#if 0
	unsigned short tmpLen;
	memcpy((void *)&tmpLen, (void *)ptr, sizeof(unsigned short));
	printf("tmpLen = %d, %d\n", tmpLen, ntohs(tmpLen));
#endif

	ptr += 2;

	*ptr++ = 0;

	*ptr++ = 0xFB;
	*ptr++ = 0x14;
	*ptr++ = cmd;

	if (nDataSize > 0)
	{
		memcpy((void *)ptr, pData, nDataSize);
		ptr += nDataSize;
	}

	*ptr++ = 0x03;

	unsigned short * cic = (unsigned short *)ptr;
	get_crc((unsigned char *)LEN, 7 + nDataSize, cic);
	*cic = htons(*cic);

	printf("DEBUG, SendToKicc, send = %d\n", 10 + nDataSize);
	if (pIomp->TcpCompleteSend((char *)pPacket, 10 + nDataSize) == -1)
		return -1;

	return 0;
}


/// - log part ////////////////////////////////////////////
extern inline FILE * CtLogFilePtr(FILE * pNewFile = NULL)
{
	static FILE * pFile = stdout;
	if (pNewFile)
		pFile = pNewFile;

	return pFile;
}

extern inline void CtLog(int nLevel, const char *fmt, ...)
//void CtLog(int nLevel, const char * pszLog)
{
    char szLogString[1024];
    va_list vaList;
    va_start(vaList, fmt);

#if defined(__ANDROID__) || defined(ANDROID)
    if (vsnprintf(szLogString, 1023, fmt, vaList) > 1023)
        szLogString[1023] = '\0';
    va_end(vaList);

    __android_log_print(ANDROID_LOG_ERROR, "CtSense", "%s", szLogString);
#else
	time_t t = time(NULL);
    struct tm * st = localtime(&t);
    sprintf(szLogString, "%04d-%02d-%02d %02d:%02d:%02d ", 1900 + st->tm_year, 
		st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);
	fputs(szLogString, CtLogFilePtr());

	if (vsnprintf(szLogString, 1023, fmt, vaList) > 1023)
		szLogString[1023] = '\0';

	va_end(vaList);

    fputs(szLogString, CtLogFilePtr());
#endif
}
/// - log part ////////////////////////////////////////////


///BeginHeader- protocol part /////////////////////////////////////////////////
struct CtProtocolRecvCallBack
{
	virtual int OnRecvProtocol() = 0;
};


class CtProtocol
{
public:
	enum
	{
		CP_STATE_EMPTY = 0,
		CP_STATE_INVALID_PACKET = 1,
		CP_STATE_HEADER_REMAIN = 2,
		CP_STATE_BODY_REMAIN = 3,
		CP_STATE_COMPLETE = 4,
		CP_STATE_JOINED = 5,
	};

public:
	inline CtProtocol();
	virtual inline ~CtProtocol();

	inline int GetPacketSize() { return m_nPakcetSize; }
	inline int GetBodySize() { return m_nBodySize; }
	inline const unsigned char * GetPacketPtr() { return m_pBufPtr; }
	inline const unsigned char * GetBodyPtr() { return m_pBodyPtr; }
	
	inline unsigned char * GetBufRecvPtr() { return m_pBufRecvPtr; }
	inline const int GetBufRemainSize() { return m_nBufRemainSize; }
	inline const int MoveBufRecvPtr(int nSize);

	inline int OnReceive(size_t nSize, CtProtocolRecvCallBack * pCallBack);

	virtual void Clear() = 0;
	virtual int Parse(const char * pPacket, int nSize) = 0;
	virtual int MoveNext() = 0;

protected:
	int m_nState;
	
	int m_nPakcetSize;
	int m_nBodySize;
	unsigned char * m_pBodyPtr;
	unsigned char * m_pBufPtr;
	//int m_nNextSendPos;

	int m_nBufRemainSize;
	unsigned char * m_pBufRecvPtr;
};
///EndHeader- protocol part ///////////////////////////////////////////////




///BeginSource- protocol part /////////////////////////////////////////////////
inline CtProtocol::CtProtocol()
{
	m_nState = CP_STATE_EMPTY;
	m_nPakcetSize = 0;
	m_nBodySize = 0;
	m_pBodyPtr = NULL;
	m_pBufPtr = NULL;
	m_nBufRemainSize = 0;
	m_pBufRecvPtr = NULL;
}

inline CtProtocol::~CtProtocol()
{
}

inline const int CtProtocol::MoveBufRecvPtr(int nSize) {
	if (m_nBufRemainSize < nSize)
		return -1;

	m_pBufRecvPtr += nSize;
	m_nPakcetSize += nSize;
	m_nBufRemainSize -= nSize;

	return 0;
}

inline int CtProtocol::OnReceive(size_t nSize, CtProtocolRecvCallBack * pCallBack)
{
	CtLog(15, "CtProtocol::OnReceive, nSize = %d\n", nSize);
	CtLog(15, "CtProtocol::OnReceive, %x %x %x %x %x %x\n", m_pBufRecvPtr[0], m_pBufRecvPtr[1], m_pBufRecvPtr[2], m_pBufRecvPtr[3], m_pBufRecvPtr[4], m_pBufRecvPtr[5]);

	if (MoveBufRecvPtr((int)nSize) < 0)
	{
		CtLog(1, "[ERROR], CtProtocol::MoveBufRecvPtr, Not enough buffer.\n");
		return -1;	// disconnect
	}

	for (;;)
	{
#ifdef USE_COPY_BUFFER
		int nState = Parse(m_pRecvBuf, nSize);
#else
		int nState = Parse(NULL, 0);
#endif
		if (nState == CP_STATE_COMPLETE || nState == CP_STATE_JOINED)
		{
			if (pCallBack->OnRecvProtocol() < 0)
				return -1;	// disconnect

			if (nState == CP_STATE_COMPLETE)
			{
				Clear();
			}
			else if (nState == CP_STATE_JOINED)
			{
				MoveNext();
				continue;
			}
		}

		break;
	}
	Clear();
	
	//return -1;	//TestCode disconnect
	return 0;
}
///EndSource- protocol part ///////////////////////////////////////////////////


class KiccProtocol : public CtProtocol
{
	// STX: 1byte, 0x02 : Start of Transmission
	// LEN: 2byte, ���� ��Ŷ ����(LEN���� DATA����)
	// CNT: 1byte, ��Ŷ Counter. ��Ŷ�� �ۼ��� �� ������ 1�� �����ϸ�, 1���� 255���� ����. ������ 1�� Reset��.
	// CMD: 1byte, �⺻ �ڵ�
	// GCD: 1byte, �׷� �ڵ� ( ������ �׷� �ڵ� )
	// JCD: 1byte, ���� �ڵ� ( ���� ���� �ڵ� )
	// DATA: LEN byte, ���� ����. ���� �ڵ� ������ �����ϱ� ���� �ʿ��� ������ �ʵ�. ������ ������ Type���� ���۵Ǹ�, ASCII�� ��?���� ����.
	// ETX: 1byte, End of Transmission
	// CRC: 2byte, LEN���� ETX������ Check Code
public:
	enum
	{
		CP_MAX_PACKET_SIZE = 8192,
		CP_HEADER_SIZE = 3,	// STX + LEN
		CP_MAX_BODY_SIZE = CP_MAX_PACKET_SIZE - CP_HEADER_SIZE,
	};

public:
	inline KiccProtocol();
	virtual inline ~KiccProtocol();

	inline void Clear();

	inline void Append(const char * pData, size_t nSize);
	inline void SetHeader(unsigned short nBodySize);
	inline void BuildHeader();

	inline int Parse(const char * pPacket, int nSize);
	inline int MoveNext();

protected:
	unsigned char m_buffer[CP_MAX_PACKET_SIZE];
};


inline KiccProtocol::KiccProtocol()
{
	Clear();
}

inline KiccProtocol::~KiccProtocol()
{
}

inline void KiccProtocol::Clear()
{
	m_nState = CP_STATE_EMPTY;
	m_nPakcetSize = 0;
	m_nBodySize = 0;
	m_pBodyPtr = m_buffer + CP_HEADER_SIZE;
	m_pBufPtr = m_buffer;	
	m_nBufRemainSize = CP_MAX_PACKET_SIZE;
	m_pBufRecvPtr = m_buffer;
}

inline void KiccProtocol::Append(const char * pData, size_t nSize)
{ 
	memcpy(m_pBodyPtr + m_nBodySize, pData, nSize);
	m_nBodySize += (int)nSize;
}

inline void KiccProtocol::SetHeader(unsigned short nBodySize)
{ 
//	memcpy(m_buffer, ProtocolNamePtr(), 4);
	unsigned short * pnBodySize = (unsigned short *)(m_buffer + 4);
	*pnBodySize = htons(nBodySize);
	m_nBodySize = nBodySize;
	m_nPakcetSize = m_nBodySize + CP_HEADER_SIZE;
}

inline void KiccProtocol::BuildHeader()
{ 
//	memcpy(m_buffer, ProtocolNamePtr(), 4);
	unsigned short * pnBodySize = (unsigned short *)(m_buffer + 4);
	*pnBodySize = htons(m_nBodySize);
	m_nPakcetSize = m_nBodySize + CP_HEADER_SIZE;
	m_nState = CP_STATE_COMPLETE;
}

inline int KiccProtocol::Parse(const char * pPacket, int nSize)
{
	if (m_nState == CP_STATE_JOINED)
	{
		m_nState = CP_STATE_EMPTY;
	}
	else
	{
		if (pPacket != NULL && nSize != 0)
		{
			memcpy(m_buffer + m_nPakcetSize, pPacket, nSize);
			m_nPakcetSize += nSize;
		}
	}

	//fprintf(stdout, "DEBUG, Parse 1, %d, %d, %d, %d\n", nSize, m_nState, m_nPakcetSize, m_nBodySize);

	if (m_nState == CP_STATE_EMPTY)
	{
		if (m_nPakcetSize < CP_HEADER_SIZE)
		{
			m_nState = CP_STATE_HEADER_REMAIN;
			return m_nState;
		}
	}
	else if (m_nState == CP_STATE_HEADER_REMAIN)
	{
		if (m_nPakcetSize < CP_HEADER_SIZE)
			return m_nState;
	}
	else if (m_nState == CP_STATE_BODY_REMAIN)
	{
		if (m_nPakcetSize < CP_HEADER_SIZE + m_nBodySize)
			return m_nState;

		return CP_STATE_COMPLETE; 
	}

	//fprintf(stdout, "DEBUG, Parse 2, %x, %x, %x\n", m_pBufPtr[0], m_pBufPtr[1], m_pBufPtr[2]);

//	if (memcmp(m_pBufPtr, KiccProtocol::ProtocolNamePtr(), 4) != 0)
	if (m_pBufPtr[0] != 0x02 && m_pBufPtr[0] != 0x06 && m_pBufPtr[0] != 0x14)
		return CP_STATE_INVALID_PACKET;
	else if (m_pBufPtr[0] == 0x06 && m_pBufPtr[1] == 0x06 && m_pBufPtr[2] == 0x06)
	{
		m_nBodySize = 0;
		return CP_STATE_COMPLETE;	//ACK
	}
	else if (m_pBufPtr[0] == 0x15 && m_pBufPtr[1] == 0x15 && m_pBufPtr[2] == 0x15)
	{
		m_nBodySize = 0;
		return CP_STATE_COMPLETE;	//NACK
	}

	//m_nBodySize = ntohs(*((unsigned short *)(m_pBufPtr + 4)));
	unsigned short nBodySize;
	memcpy(&nBodySize, m_pBufPtr + 1, sizeof(unsigned short));
	m_nBodySize = ntohs(nBodySize);

	if (m_nBodySize == 0)
	{
		m_nBodySize = 7;	// CNT(1) + CMD(1) + GCD(1) + JCD(1) + ETX(1) + CRC(2)

		if ((m_nBodySize - 7) > m_nPakcetSize - CP_HEADER_SIZE)
		{
			m_nState = CP_STATE_BODY_REMAIN;
			return m_nState;
		}
		else if ((m_nBodySize - 7) < m_nPakcetSize - CP_HEADER_SIZE)
		{
			m_nState = CP_STATE_JOINED;
			return m_nState;
		}
	}
	else
	{
		m_nBodySize++;	// - LEN(2) + ETX(1) + CRC(2)

		if ((m_nBodySize - 1) > m_nPakcetSize - CP_HEADER_SIZE)
		{
			m_nState = CP_STATE_BODY_REMAIN;
			return m_nState;
		}
		else if ((m_nBodySize - 1) < m_nPakcetSize - CP_HEADER_SIZE)
		{
			m_nState = CP_STATE_JOINED;
			return m_nState;
		}
	}

	return CP_STATE_COMPLETE;
}

inline int KiccProtocol::MoveNext()
{
	if (m_nState != CP_STATE_JOINED)
		return -1;

	m_pBufPtr += CP_HEADER_SIZE + m_nBodySize;
	m_pBodyPtr = m_pBufPtr + CP_HEADER_SIZE;
	m_nPakcetSize -= CP_HEADER_SIZE + m_nBodySize;

	return 0;
}
////////////////////////////////////////////////////////////////////////////////
///BeginHeader- size only protocol part /////////////////////////////////////////////////
class CtSizeOnlyProtocol : public CtProtocol
{
public:
	enum
	{
		CP_MAX_PACKET_SIZE = 8192,
		CP_HEADER_SIZE = 4,	// PROTOCOL_NAME + BODY_SIZE(2byte)
		CP_MAX_BODY_SIZE = CP_MAX_PACKET_SIZE - CP_HEADER_SIZE,
	};

public:
	inline CtSizeOnlyProtocol();
	virtual inline ~CtSizeOnlyProtocol();

	inline void Clear();

	inline void Append(const char * pData, size_t nSize);
	inline void SetHeader(u_short nBodySize);
	inline void BuildHeader();

	inline int Parse(const char * pPacket, int nSize);
	inline int MoveNext();

protected:
	unsigned char m_buffer[CP_MAX_PACKET_SIZE];
};
///EndHeader- size only protocol part ///////////////////////////////////////////////




///BeginSource- size only protocol part /////////////////////////////////////////////////
inline CtSizeOnlyProtocol::CtSizeOnlyProtocol()
{
	Clear();
}

inline CtSizeOnlyProtocol::~CtSizeOnlyProtocol()
{
}

inline void CtSizeOnlyProtocol::Clear()
{
	m_nState = CP_STATE_EMPTY;
	m_nPakcetSize = 0;
	m_nBodySize = 0;
	m_pBodyPtr = m_buffer + CP_HEADER_SIZE;
	m_pBufPtr = m_buffer;	
	m_nBufRemainSize = CP_MAX_PACKET_SIZE;
	m_pBufRecvPtr = m_buffer;
}

inline void CtSizeOnlyProtocol::Append(const char * pData, size_t nSize)
{ 
	memcpy(m_pBodyPtr + m_nBodySize, pData, nSize);
	m_nBodySize += (int)nSize;
}

inline void CtSizeOnlyProtocol::SetHeader(u_short nBodySize)
{ 
	//memcpy(m_buffer, ProtocolNamePtr(), 4);
	unsigned short * pnBodySize = (unsigned short *)(m_buffer + 4);
	*pnBodySize = htons(nBodySize);
	m_nBodySize = nBodySize;
	m_nPakcetSize = m_nBodySize + CP_HEADER_SIZE;
}

inline void CtSizeOnlyProtocol::BuildHeader()
{ 
	//memcpy(m_buffer, ProtocolNamePtr(), 4);
	unsigned short * pnBodySize = (unsigned short *)(m_buffer + 4);
	*pnBodySize = htons(m_nBodySize);
	m_nPakcetSize = m_nBodySize + CP_HEADER_SIZE;
	m_nState = CP_STATE_COMPLETE;
}

inline int CtSizeOnlyProtocol::Parse(const char * pPacket, int nSize)
{
	if (m_nState == CP_STATE_JOINED)
	{
		m_nState = CP_STATE_EMPTY;
	}
	else
	{
		if (pPacket != NULL && nSize != 0)
		{
			memcpy(m_buffer + m_nPakcetSize, pPacket, nSize);
			m_nPakcetSize += nSize;
		}
	}

	if (m_nState == CP_STATE_EMPTY)
	{
		if (m_nPakcetSize < CP_HEADER_SIZE)
		{
			m_nState = CP_STATE_HEADER_REMAIN;
			return m_nState;
		}
	}
	else if (m_nState == CP_STATE_HEADER_REMAIN)
	{
		if (m_nPakcetSize < CP_HEADER_SIZE)
			return m_nState;
	}
	else if (m_nState == CP_STATE_BODY_REMAIN)
	{
		if (m_nPakcetSize < CP_HEADER_SIZE + m_nBodySize)
			return m_nState;

		return CP_STATE_COMPLETE; 
	}

	//if (memcmp(m_pBufPtr, CtSizeOnlyProtocol::ProtocolNamePtr(), 4) != 0)
	//	return CP_STATE_INVALID_PACKET;

	//m_nBodySize = ntohs(*((u_short *)(m_pBufPtr + 4)));
	unsigned short nBodySize;
	memcpy(&nBodySize, m_pBufPtr + 2, sizeof(unsigned short));
	m_nBodySize = ntohs(nBodySize);

	if (m_nBodySize > m_nPakcetSize - CP_HEADER_SIZE)
	{
		m_nState = CP_STATE_BODY_REMAIN;
		return m_nState;
	}
	else if (m_nBodySize < m_nPakcetSize - CP_HEADER_SIZE)
	{
		m_nState = CP_STATE_JOINED;
		return m_nState;
	}

	return CP_STATE_COMPLETE;
}

inline int CtSizeOnlyProtocol::MoveNext()
{
	if (m_nState != CP_STATE_JOINED)
		return -1;

	m_pBufPtr += CP_HEADER_SIZE + m_nBodySize;
	m_nPakcetSize -= CP_HEADER_SIZE + m_nBodySize;

	return 0;
}
///////////////////////////////////////////////////////////////////////////



class KiccDispatcher;


class KiccRecvCallBack : public CtProtocolRecvCallBack
{
public:
	KiccRecvCallBack() {}
	virtual ~KiccRecvCallBack() {}

	void SetDepends(KiccProtocol * pKiccProtocol, KiccDispatcher * pKiccDispatcher)
	{
		m_pKiccProtocol = pKiccProtocol;
		m_pKiccDispatcher = pKiccDispatcher;
	}

	virtual int OnRecvProtocol();

protected:
	KiccProtocol * m_pKiccProtocol;
	KiccDispatcher * m_pKiccDispatcher;
};

class RemoteRecvCallBack : public CtProtocolRecvCallBack
{
public:
	RemoteRecvCallBack() {}
	virtual ~RemoteRecvCallBack() {}

	void SetDepends(CtSizeOnlyProtocol * pSoProtocol, KiccDispatcher * pKiccDispatcher)
	{
		m_pSoProtocol = pSoProtocol;
		m_pKiccDispatcher = pKiccDispatcher;
	}

	virtual int OnRecvProtocol();

protected:
	CtSizeOnlyProtocol * m_pSoProtocol;
	KiccDispatcher * m_pKiccDispatcher;
};
//////////////////////////////////////////////////////////////////////////////

class KiccIompObject: public IompObject
{
public:
	//KiccIompObject * m_pPair;

public:
	KiccIompObject()
	{
		//m_pPair = NULL;
	}

	~KiccIompObject() {}
};

#if 0
typedef struct TTerminalInfo
{
	unsigned char nRespCode;
	char arrModelCode[4];
	char arrModelVer[4];
	char arrSerialNo[12];
	char arrCertNo[16];
	char arrTid[10];
	char arrTerminalNo[3];
	char arrTerminalIpPort[30];
	char * pSpecialInfo;
} TTerminalInfo;
#endif

class KiccDispatcher : public IompDispatcher<KiccIompObject>
{
public:
	enum 
	{
		KD_KICC_STATE_STARTED = 0,
		KD_KICC_STATE_WAIT_CONNECT = 1,
		KD_KICC_STATE_CONNECTED = 2
	};
	
	enum 
	{
		KD_REMOTE_STATE_STARTED = 0,
		KD_REMOTE_STATE_WAIT_CONNECT = 1,
		KD_REMOTE_STATE_WAIT_LOGIN_OK = 2,
		KD_REMOTE_STATE_LOGGED_IN = 3,
	};

protected:
	//int m_nState;
	int m_nKiccState;
	int m_nRemoteState;
	char m_szTid[16];

	KiccIompObject * m_pKiccIompObject;
	KiccIompObject * m_pRemoteIompObject;

	KiccProtocol m_kiccProtocol;
	KiccRecvCallBack m_kiccRecvCallBack;

	CtSizeOnlyProtocol m_remoteProtocol;
	RemoteRecvCallBack m_remoteRecvCallBack;

public:
	KiccDispatcher()
	{
		m_nKiccState = KD_KICC_STATE_STARTED;
		m_nRemoteState = KD_REMOTE_STATE_STARTED;
		m_szTid[0] = '\0';
	}

	virtual ~KiccDispatcher()
	{
	}

	void SetTimer(unsigned int nIntervalTime)	//msec
	{
		m_nDispachInterval = nIntervalTime;
	}

	void KillTimer()
	{
		m_nDispachInterval = 0;
	}

	void SendToRemote(int nType, const char * pData, int nDataSize)
	{
		char packet[8192];
		char * ptrBodySize = (char *)packet + 2;
		char * ptrBody = ptrBodySize + 2;

		ptrBody[0] = nType;	// 1: Command Protocol, 2: KICC protocol
		
		unsigned short nBodySize = nDataSize;
		memcpy(ptrBody + 1, pData, nBodySize);
		nBodySize += 1;

		unsigned short nTemp = htons(nBodySize);
		memcpy(ptrBodySize, &nTemp, sizeof(unsigned short));

		fprintf(stdout, "DEBUG, SendToRemote, size = %d, \n", nBodySize + 4);
		m_pRemoteIompObject->TcpCompleteSend(packet, nBodySize + 4);	// send kicc protocol to server
	}

	void SendTest1ToRemote(int nType)
	{
		char szFileName[128];
		sprintf(szFileName, "pay%.2d.raw", nType);

		CtFile file;
		if (file.Open(szFileName, CtFile::FMODE_RDONLY) == false)
			return;

		char buffer[8192];
		size_t nRecvSize = file.Read(buffer, 8192);
		if (nRecvSize <= 0)
			return;

		SendToRemote(2, buffer, nRecvSize);
	}

	int OnRecvKiccProtocol()	// m_nKiccState == KD_KICC_STATE_CONNECTED
	{
		if ((m_kiccProtocol.GetPacketPtr()[0] == 0x06 && m_kiccProtocol.GetPacketPtr()[1] == 0x06 && m_kiccProtocol.GetPacketPtr()[2] == 0x06) || 
			m_kiccProtocol.GetPacketPtr()[0] == 0x15 && m_kiccProtocol.GetPacketPtr()[1] == 0x15 && m_kiccProtocol.GetPacketPtr()[2] == 0x15)	// ACK
		{
			fprintf(stdout, "DEBUG, OnRecvKiccProtocol, ACK/NACK, 0x%x, size = %d\n", m_kiccProtocol.GetPacketPtr()[0], m_kiccProtocol.GetPacketSize());

			if (m_nRemoteState == KD_REMOTE_STATE_LOGGED_IN)
			{
				SendToRemote(2, (const char *)m_kiccProtocol.GetPacketPtr(), m_kiccProtocol.GetPacketSize());
			}
			
			return 0;
		}

		fprintf(stdout, "DEBUG, OnRecvKiccProtocol, body size = %d, 0x%.2d, 0x%.2d, 0x%.2d\n", m_kiccProtocol.GetBodySize(), m_kiccProtocol.GetBodyPtr()[0], m_kiccProtocol.GetBodyPtr()[1], m_kiccProtocol.GetBodyPtr()[2]);

		unsigned char ack[4];
		ack[0] = 0x06;
		ack[1] = 0x06;
		ack[2] = 0x06;
		m_pKiccIompObject->TcpCompleteSend((const char *)ack, 3);	// response ack

		if (m_nRemoteState == KD_REMOTE_STATE_STARTED)
		{
			const char * ptrTid = (const char *)m_kiccProtocol.GetBodyPtr() + 41;
			int j = 0;
			for (int i = 0; i < 10; i++)	// front trim
			{
				if (ptrTid[i] == ' ')
					continue;

				m_szTid[j++] = ptrTid[i];
			}
			m_szTid[j] = '\0';

			fprintf(stdout, "DEBUG, OnRecvKiccProtocol, Tid = %s\n", m_szTid);
			
			if (m_szTid[0] == '\0')
			{
				//...
				SendToKicc(m_pKiccIompObject, 0x02, NULL, 0);	// get info
				return 0;
			}


			KiccIompObject iompObject;
			if (iompObject.Create() == -1)
				return 0;

			//if (iompObject.Connect("192.168.219.150", 17856, 7000, 0, 5000) == -1)
			if (iompObject.Connect("43.201.46.125", 17856, 7000, 0, 5000) == -1)
				return 0;

			m_remoteRecvCallBack.SetDepends(&m_remoteProtocol, this);
			m_pRemoteIompObject = AddSocket(iompObject);
			
			m_nRemoteState = KD_REMOTE_STATE_WAIT_CONNECT;

			return 0;
		}
		else if (m_nRemoteState == KD_REMOTE_STATE_WAIT_CONNECT)
		{
			//...
		}
		else if (m_nRemoteState == KD_REMOTE_STATE_WAIT_LOGIN_OK)
		{
			//...
		}
		else if (m_nRemoteState == KD_REMOTE_STATE_LOGGED_IN)
		{
			SendToRemote(2, (const char *)m_kiccProtocol.GetPacketPtr(), m_kiccProtocol.GetPacketSize());
		}

		return 0;
	}

	int OnRecvRemoteProtocol()	// m_nRemoteState == KD_REMOTE_STATE_WAIT_LOGIN_OK or KD_REMOTE_STATE_LOGGED_IN
	{
		fprintf(stdout, "DEBUG, OnRecvRemoteProtocol, body size = %d, 0x%.2d, 0x%.2d\n", m_remoteProtocol.GetBodySize(), m_remoteProtocol.GetBodyPtr()[0], m_remoteProtocol.GetBodyPtr()[1]);
		const unsigned char * pPacket = m_remoteProtocol.GetPacketPtr();

		fprintf(stdout, "DEBUG, %x %x %x %x %x\n", pPacket[0], pPacket[1], pPacket[2], pPacket[3], pPacket[4], pPacket[5]);

		if (m_nRemoteState == KD_REMOTE_STATE_WAIT_LOGIN_OK)
		{
			if (m_remoteProtocol.GetBodyPtr()[0] == 1 && // smart service protocol
				m_remoteProtocol.GetBodyPtr()[1] == 1)	// login ok
			{
				fprintf(stdout, "DEBUG, OnRecvRemoteProtocol, login success\n");
				m_nRemoteState = KD_REMOTE_STATE_LOGGED_IN;
				return 0;
			}
			
			//login failed
			return -1;	// disconnect
		}
		
		if (m_nKiccState == KD_KICC_STATE_WAIT_CONNECT)
		{
			//...
			return 0;
		}
		else if (m_nKiccState == KD_KICC_STATE_CONNECTED)
		{
			if (m_remoteProtocol.GetBodyPtr()[0] == 1)	// remote server protocol
			{
				if (m_remoteProtocol.GetBodyPtr()[1] == 2)	// keep-alive
				{
					fprintf(stdout, "DEBUG, OnRecvRemoteProtocol, keep-alive\n");
					SendToRemote(1, "3", 1);	// keep-alive ack
				}
				else if (m_remoteProtocol.GetBodyPtr()[1] == 99)	// test packet
				{
					SendTest1ToRemote(m_remoteProtocol.GetBodyPtr()[2]);
				}

				return 0;
			}
			else if (m_remoteProtocol.GetBodyPtr()[0] == 2)	// kicc protocol
			{
				const char * pBody = (const char *)m_remoteProtocol.GetBodyPtr();
				m_pKiccIompObject->TcpCompleteSend(pBody + 1, m_remoteProtocol.GetBodySize() - 1);	// remove protocol type
				return 0;
			}
			
			return 0;	// disconnect
		}

		return -1;	// disconnect
	}

protected:
	int OnIompConnect(KiccIompObject * pIomp, bool bIsSuccess, unsigned int nCurrTick)
	{
		fprintf(stdout, "DEBUG, OnIompConnect, %s, state = %d, sock = %d\n", bIsSuccess ? "true" : "false", m_nKiccState, m_nRemoteState, pIomp->m_sock);
		if (bIsSuccess == false)
			return 0;
		
		if (m_pKiccIompObject == pIomp)
		{
			if (m_szTid[0] == '\0')
			{
				SendToKicc(pIomp, 0x02, NULL, 0);	// get info
			}

			m_nKiccState = KD_KICC_STATE_CONNECTED;
		}
		else if (m_pRemoteIompObject == pIomp)
		{
			//
			char packet[8192];
			char * ptrBodySize = (char *)packet + 2;
			char * ptrBody = ptrBodySize + 2;

			ptrBody[0] = 1;	// 1: Command Protocol, 2: KICC protocol
			ptrBody[1] = 1;	// 1: Login

			//int nBodySize = sprintf(ptrBody + 2, "%s", m_szTid);
			unsigned int nBodySize = strlen(m_szTid);
			memcpy(ptrBody + 2, m_szTid, nBodySize);

			nBodySize += 2;
			unsigned short nTemp = htons(nBodySize);
			memcpy(ptrBodySize, &nTemp, sizeof(unsigned short));

			fprintf(stdout, "DEBUG, Send, size = %d, \n", nBodySize + 4);
			m_pRemoteIompObject->TcpCompleteSend(packet, nBodySize + 4);	// send login
			//

			m_nRemoteState = KD_REMOTE_STATE_WAIT_LOGIN_OK;
		}

		return 0;
	}

	int OnIompReceive(KiccIompObject * pIomp, unsigned int nCurrTick)
	{
		if (m_pKiccIompObject == pIomp)
		{
			int nReceived = pIomp->Receive((char *)m_kiccProtocol.GetBufRecvPtr(), m_kiccProtocol.GetBufRemainSize());
			if (nReceived == -1)
				return -1;

			return m_kiccProtocol.OnReceive(nReceived, &m_kiccRecvCallBack);
		}
		else if (m_pRemoteIompObject == pIomp)
		{
			int nReceived = pIomp->Receive((char *)m_remoteProtocol.GetBufRecvPtr(), m_remoteProtocol.GetBufRemainSize());
			if (nReceived == -1)
				return -1;

			return m_remoteProtocol.OnReceive(nReceived, &m_remoteRecvCallBack);
		}

		return -1;	// disconnect
	}

	int OnIompAccept(KiccIompObject * pIomp, unsigned int nCurrTick)
	{
		fprintf(stdout, "DEBUG, OnIompAccept, sock = %d\n", pIomp->m_sock);

		return 0;
	}

	int OnIompClose(KiccIompObject * pIomp, unsigned int nCurrTick)
	{
		fprintf(stdout, "DEBUG, OnIompClose, sock = %d\n", pIomp->m_sock);

		if (m_pKiccIompObject == pIomp)
		{
			m_kiccProtocol.Clear();
			m_nKiccState = KD_KICC_STATE_WAIT_CONNECT;
		}
		else if (m_pRemoteIompObject == pIomp)
		{
			m_remoteProtocol.Clear();
			m_nRemoteState = KD_REMOTE_STATE_WAIT_CONNECT;
		}

		return 0;	//default, remove from dispatch list
		//return -1;	//!!! no remove from dispatch list
	}

	int OnIompDelete(KiccIompObject * pIomp, unsigned int nCurrTick)
	{
		fprintf(stdout, "DEBUG, OnIompDelete, sock = %d\n", pIomp->m_sock);

		return 0;
	}

	void OnDispatchTimer(unsigned int nCurrTick)
	{
		fprintf(stdout, "DEBUG, %u, OnDispatchTimer, m_listIomp.size() = %ld\n", nCurrTick, m_listIomp.size());

		if (m_nKiccState == KD_KICC_STATE_STARTED)
		{
			KiccIompObject iompObject;
			if (iompObject.Create() == -1)
				return;

			if (iompObject.Connect("127.0.0.1", 13189, 7000, nCurrTick, 5000) == -1)
			//if (iompObject.Connect("192.168.219.150", 13189, 7000, 5000) == -1)
				return;

			m_kiccRecvCallBack.SetDepends(&m_kiccProtocol, this);
			m_pKiccIompObject = AddSocket(iompObject);

			m_nKiccState = KD_KICC_STATE_WAIT_CONNECT;	// local connecting...
			KillTimer();
		}
	}
};


int KiccRecvCallBack::OnRecvProtocol()
{
	return m_pKiccDispatcher->OnRecvKiccProtocol();
}

int RemoteRecvCallBack::OnRecvProtocol()
{
	return m_pKiccDispatcher->OnRecvRemoteProtocol();
}



int main (int argc, char * argv[])
{
	//if (argc < 3)
	//{
	//	printf("Usage: hdtermd [IP] [Port]\n"
	//		"ex) hdtermd 192.168.1.4 7788\n");
	//	return 0;
	//}

#if defined(_WIN32) && defined(_DEBUG)
	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
	//_CrtSetBreakAlloc(631);
#endif	// _DEBUG

#ifdef _WIN32
	WSADATA wsaData;
	WORD wVersionRequested = MAKEWORD(2, 2);
	if (WSAStartup(wVersionRequested, &wsaData) != 0)
	{
		printf("[ERROR], Windows sockets initialization failed., WSAGetLastError = %d\n", WSAGetLastError());
		return -1;
	}
	
	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
	{
		printf("[ERROR], Could not find a usable WinSock DLL.\n");
		WSACleanup();
		return -1;
	}
#endif	// _WIN32

	fprintf(stdout, "hdtermd version 1.0.2\n");

	// verify date
	for (;;)
	{
		time_t now;
		struct tm *local;

		time(&now);
		local = localtime(&now);

		int year = local->tm_year + 1900;

		if (year < 2026)
		{
			fprintf(stderr, "[ERROR], Invalid date,  = %ld\n", year);
			Sleep(5000);
			continue;
		}

		break;
	}
	//
	
	KiccDispatcher iompDispatcher;
	iompDispatcher.SetTimer(2000);
	iompDispatcher.Dispatch();	// loop
	
	return 0;
}