#include "SHSSDK.h"
#include "main.h"

#undef HAVE_SSPI

#include "ne_request.h"
#include "ne_socket.h"
#include "ne_string.h"
#ifdef WIN32
#include "../Common/global_def.h"

#pragma comment(lib, "ws2_32.lib")
#endif

#ifndef WIN32
#define AUTHPRIME            137897
typedef struct _s_time_sync_t
{
    int32_t sync_info;	
}time_sync_t;
#endif

#pragma pack(1)
typedef struct {
	char id[32];
	char domain[128];
    char domain2[128];
} SERVICE_STRUCT, *PSERVICE_STRUCT;
#pragma pack()

#pragma pack(1)
typedef struct {
	char    szTranId[52];
	__int32 nMode;
	char    szIssuer[128];
	char    szServiceId[128];
	__int32 nResult;
	__int32 nLength;
} COMMAND_STRUCT, *PCOMMAND_STRUCT;
#pragma pack()

#define CENTER_HOST G_CENTERADDR
#define CENTER_PORT 80

#define RESOURCE_PORT	13104
#define GTLLOG_PORT		13103
//#define RESOURCE_PORT 80

#define PRIVATE_KEY "I'm your father"
#define SERVER_NAME "SHSSDK"

#define DELIMITER					0x1b

#define MSG_MODE_GET_FILE_NAME							0x010b
#define MSG_MODE_SSDK_GTS_GET_TRANSFER_LOG				0x0311
#define MSG_MODE_GTS_SSDK_SEND_TRANSFER_LOG				0x0312
#define MSG_MODE_SSDK_GTS_SEND_TRANSFER_LOG_RESP		0x0313

/* Elenoa MOD : START */
/* default timeout 5 second */
#include <fcntl.h>

static int timeout = 5;
static char szCacheFile[MAX_PATH]={0};
static int _sh_send(SOCKET s, char *buf, int len);
static int _sh_recv(SOCKET s, char *buf, int len);
const  char *sh_get_rcts_host(const char *userId, const char *password, const char *serviceId);
char* get_address(const char *userId, const char *password, const char *serviceId,int nFlag);
int get_psl_from_cache(PSERVICE_STRUCT *psl);
int set_psl_to_cache(PSERVICE_STRUCT *psl,int nCount);

#ifdef _WIN32
static int __nonblock_win32(SOCKET s)
{
	int ul = 1;
	int result;
	
	result = ioctlsocket( s, FIONBIO, (u_long FAR*)&ul );

	return result;
}
#else
static int __nonblock(int fd)
{
	int result;
	int flags;

	flags = fcntl(fd, F_GETFL, 0);
	result = fcntl(fd, F_SETFL, flags | O_NONBLOCK);

	return result;
}
#endif

void sh_set_timeout(int second)
{
	timeout = second;
}
/* Elenoa MOD : END */

int get_psl_from_cache(PSERVICE_STRUCT *psl)
{
	int nCount = 0;
	FILE* fp=NULL;
	int i=0;
	int numread=0;

	if (strlen(szCacheFile) == 0)
		return 0;

	fp = fopen(szCacheFile,"rb");

	if(fp)
	{
		fread(&nCount,sizeof(int),1,fp);
		
		*psl = malloc(sizeof(SERVICE_STRUCT) * nCount);
		numread = fread(*psl,sizeof(SERVICE_STRUCT) * nCount,1,fp);

		if (numread < 1)
		{
			SetLastError(SHERRNO_INVALIDCACHEFILE);
			return 0;
		}

		fclose(fp);
	}
	return nCount;
}

int set_psl_to_cache(PSERVICE_STRUCT *psl,int nCount)
{
	FILE* fp=NULL;
	int i=0;

	if (strlen(szCacheFile) == 0)
		return 0;

	fp = fopen(szCacheFile,"wb");

	if (fp)
	{
		fwrite(&nCount,sizeof(int),1,fp);

		fwrite(*psl,sizeof(SERVICE_STRUCT)*nCount,1,fp);
		fclose(fp);
	}

	return 1;
}

time_t get_time_from_sntp()
{
	char szHost[128];
	int  nRecv;
	time_sync_t	tst;
	int nWrite;
	time_sync_t *pSyncInfo = NULL;
#ifdef WIN32
	struct tm *ttm=NULL;
#endif
	SOCKET sock;
	struct sockaddr_in sa;
	long ltime;

	ltime = (long)time(NULL);

	if (ne_sock_init() != NE_OK)
	{
		return ltime;
	}

	// Get server time
	strcpy(szHost, SNTP_DOMAIN);
	if (isalpha(szHost[0]))
	{
		struct hostent *phe = gethostbyname(szHost);
		if (!phe)
		{
			return ltime;
		}

		sprintf(szHost, "%d.%d.%d.%d",
			(unsigned char)*(phe->h_addr_list[0]),     (unsigned char)*(phe->h_addr_list[0] + 1),
			(unsigned char)*(phe->h_addr_list[0] + 2), (unsigned char)*(phe->h_addr_list[0] + 3));
	}

	sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sock == INVALID_SOCKET)
	{
		return ltime;
	}

	sa.sin_family      = AF_INET;
	sa.sin_addr.s_addr = inet_addr(szHost);
	sa.sin_port        = htons(SNTP_PORT);

#ifdef WIN32
	__nonblock_win32(sock);

	if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
	{

		if (WSAEWOULDBLOCK == WSAGetLastError())
		{
			fd_set wfd, efd;
			struct timeval tv;
			FD_ZERO(&wfd);
			FD_ZERO(&efd);
			FD_SET(sock, &wfd);
			FD_SET(sock, &efd);
			tv.tv_sec = timeout;
			tv.tv_usec = 0;
			nRecv = select(0, 0, &wfd, &efd,&tv);
			if (SOCKET_ERROR == nRecv || 0 == nRecv)
			{
				int nRet = WSAGetLastError();
				return ltime;
			}
		}
		else
		{
			return ltime;
		}
	}

#else
	__nonblock(sock);
	{
		int i, nRet;
		for (i = 0; i < (timeout * 10); i++) {
			if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
				errno = 0;
				break;
			} else {
				nRet = errno;
			}
			if (errno == EISCONN)
				break;

			if (((i + 1) % 10) == 0) {
				shutdown(sock, 2);
				//close(sock);
				//fprintf(stderr, "RETRY ");
			}
			usleep(100000);
			//fprintf(stderr, "CLI %d\n", i);
		}

		if (errno != EISCONN && errno != 0)
		{
			return ltime;
		}
 	}
#endif

	tst.sync_info = ltime + AUTHPRIME - (ltime % AUTHPRIME);

	tst.sync_info = htonl(tst.sync_info);
	nWrite = _sh_send(sock, (char *)&tst, sizeof(tst));
	
	if(nWrite < 0)
	{
		closesocket(sock);
		return ltime;
	}

	nRecv = _sh_recv(sock, szHost, sizeof(szHost));
	
	if (nRecv < 4)
	{
		closesocket(sock);
		return ltime;
	}

	pSyncInfo = (time_sync_t *)&szHost;
	pSyncInfo->sync_info = ntohl(pSyncInfo->sync_info);

//	ttm = gmtime((time_t*)&pSyncInfo->sync_info);

	closesocket(sock);
	
	return pSyncInfo->sync_info;
}

char* get_address(const char *userId, const char *password, const char *serviceId,int nFlag)
{
	// define varialbles
	char *pszResult = NULL;

	char      szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256];
	__int64   nRandom;
	struct tm *ptmNow = NULL;
	time_t    tmtNow;

	COMMAND_STRUCT cmd;

	PSERVICE_STRUCT psl = NULL;
	int             i, nServiceCount = 0;

	char   szHost[30];
	SOCKET sock = INVALID_SOCKET;
	struct sockaddr_in sa;
	BOOL	bIsCache = FALSE;

	// get current time & random number
	if (ne_sock_init() != NE_OK)
	{
		SetLastError(GetLastError());
		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		return NULL;
	}

	tmtNow = get_time_from_sntp();

	srand((unsigned int)tmtNow);
	nRandom = rand() * rand();

	ptmNow = gmtime((const time_t *)&tmtNow);

	tmtNow  %= 10000000000;	// MAX 10
	nRandom %= 10000000000;	// MAX 10

	// create command struct
#ifdef WIN32
	sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#else
	sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#endif
	ne_md5_buffer(szMD5, szVerifyKey);

	ne_md5_buffer(password, szPassword);
	sprintf(szMD5, "%s%s%d", userId, szPassword, (int)tmtNow);
	ne_md5_buffer(szMD5, szPassword);

	sprintf(szAuth, "%s%c%s%c%d", userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow);

	// Make header
#ifdef WIN32
	memset((void *)&cmd, NULL, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
#else
	memset((void *)&cmd, 0, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
#endif
		ptmNow->tm_year + 1900, ptmNow->tm_mon, ptmNow->tm_wday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,
		szVerifyKey, (int)tmtNow, nRandom);

	cmd.nMode   = htonl(0x0080);
	strcpy(cmd.szIssuer, SERVER_NAME);
	cmd.nLength = htonl((u_long)strlen(szAuth));

	// create socket
	strcpy(szHost, CENTER_HOST);
	if (isalpha(szHost[0])) {
		struct hostent *phe = gethostbyname(szHost);
		if (!phe)
		{
			bIsCache = TRUE;
			goto CACHE_FUNCTION;
//			goto EXIT_FUNCTION;
		}

		memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
	}
	else
		sa.sin_addr.s_addr = inet_addr(szHost);
	
	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
	{
		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	sa.sin_family      = AF_INET;
	sa.sin_port        = htons(CENTER_PORT);

	/* Elenoa MOD : START */
#ifdef _WIN32
	__nonblock_win32(sock);  

	if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
	{

		if (WSAEWOULDBLOCK == WSAGetLastError())
		{
			fd_set wfd, efd;
			struct timeval tv;
			int result;
			FD_ZERO(&wfd);
			FD_ZERO(&efd);
			FD_SET(sock, &wfd);
			FD_SET(sock, &efd);
			tv.tv_sec = timeout;
			tv.tv_usec = 0;
			result = select(0, 0, &wfd, &efd,&tv);
			if (SOCKET_ERROR == result || 0 == result)
			{
				int nRet = WSAGetLastError();
//				goto EXIT_FUNCTION;
				bIsCache = TRUE;
				goto CACHE_FUNCTION;
			}
		}
		else
		{
			bIsCache = TRUE;
			goto CACHE_FUNCTION;
//			goto EXIT_FUNCTION;
		}
	}

#else
    __nonblock(sock);
	{
		int i;
		for (i = 0; i < (timeout * 10); i++) {
			if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
				errno = 0;
				break;
			}
			if (errno == EISCONN)
				break;

			if (((i + 1) % 10) == 0)
			{
				shutdown(sock, 2);
				//close(sock);
			}
			usleep(100000);
			//fprintf(stderr, "%d\n", i);
		}

		if (errno != EISCONN && errno != 0)
		{
			bIsCache = TRUE;
			goto CACHE_FUNCTION;
//			goto EXIT_FUNCTION;
		}
 	}
#endif
	// Send packet
	if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
	{
		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	if (_sh_send(sock, szAuth, (int)strlen(szAuth)) == SOCKET_ERROR)
	{
		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
	{
		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	cmd.nLength = ntohl(cmd.nLength);
	cmd.nResult = ntohl(cmd.nResult);
	if (cmd.nResult != 0x1000) {
		if (cmd.nResult == 0x3000)
			SetLastError(SHERRNO_UNDEFINED);
		else if (cmd.nResult == 0x3001)
			SetLastError(SHERRNO_AUTHORIZATION);
		else if (cmd.nResult == 0x9000)
			SetLastError(SHERRNO_INTERNAL);

		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	if (_sh_recv(sock, (char*)&nServiceCount, 4) == SOCKET_ERROR)
	{
		bIsCache = TRUE;
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	nServiceCount = ntohl(nServiceCount);
	psl           = malloc(sizeof(SERVICE_STRUCT) * nServiceCount);

	if (!psl)
		goto EXIT_FUNCTION;

	if (_sh_recv(sock, (char*)psl, sizeof(SERVICE_STRUCT) * nServiceCount) == SOCKET_ERROR)
	{
		bIsCache = TRUE;
		if (psl)
			free(psl);
		goto CACHE_FUNCTION;
//		goto EXIT_FUNCTION;
	}

	closesocket(sock);
	sock = INVALID_SOCKET;

	set_psl_to_cache(&psl,nServiceCount); // ij½¬ÆÄÀÏ¿¡ ±â·Ï

CACHE_FUNCTION:

	if( bIsCache)
		nServiceCount = get_psl_from_cache(&psl);

	for (i = 0; i < nServiceCount; i++) {
		if (strcmp((const char *)psl[i].id, serviceId) == 0)
		{
			switch(nFlag)
			{
			case 0: // dav address
				strcat(psl[i].domain2, "/dav");
				pszResult = strdup((const char *)psl[i].domain2);
				break;
			case 1: // rcts adress
				pszResult = strdup((const char *)psl[i].domain);
				break;
			}
			break;
		}
	}

	if (!pszResult)
		SetLastError(SHERRNO_NOSERVICE);

EXIT_FUNCTION:
	i = GetLastError();

	if (psl)
		free(psl);

	if (sock != INVALID_SOCKET)
		closesocket(sock);

	SetLastError(i);

	return pszResult;
}

const char *sh_get_service_host(const char *userId, const char *password, const char *serviceId)
{
	return get_address(userId,password,serviceId,0);
}

const char *sh_get_rcts_host(const char *userId, const char *password, const char *serviceId)
{
	return get_address(userId,password,serviceId,1);
}

const int sh_get_service_info(const char *userId, const char *password, const char *serviceId, PINT64 totalSpace, PINT64 freeSpace)
{
	// define varialbles
	int nResult = 0;

	char      szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256];
	__int64   nRandom;
	struct tm *ptmNow = NULL;
	time_t    tmtNow;
	char*	pdata;

	COMMAND_STRUCT cmd;

	char szRecvBuf[1024], *pszUsedSpace;
	int  i;

	SOCKET sock = INVALID_SOCKET;
	struct sockaddr_in sa; 

	char* pszHost = (char *)sh_get_rcts_host(userId, password, serviceId);

	if (!pszHost)
		return 0;

	pdata = strstr(pszHost,"/");

	if (pdata)
		*pdata = 0x00;

	// get current time & random number
	tmtNow = get_time_from_sntp();

//	tmtNow = time(NULL);

	srand((unsigned int)tmtNow);
	nRandom = rand() * rand();

	ptmNow = gmtime((const time_t *)&tmtNow);

	tmtNow  %= 10000000000;	// MAX 10
	nRandom %= 10000000000;	// MAX 10

	// create command struct
#ifdef WIN32
	sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#else
	sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#endif
	ne_md5_buffer(szMD5, szVerifyKey);

	ne_md5_buffer(password, szPassword);
	sprintf(szMD5, "%s@%s%s%d", serviceId, userId, szPassword, (int)tmtNow);
	ne_md5_buffer(szMD5, szPassword);

	sprintf(szAuth, "%s@%s%c%s%c%d", serviceId, userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow);

	// Make header

#ifdef WIN32
	memset((void *)&cmd, NULL, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
#else
	memset((void *)&cmd, 0, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
#endif
		ptmNow->tm_year + 1900, ptmNow->tm_mon+1, ptmNow->tm_mday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,
		szVerifyKey, (int)tmtNow, nRandom);
	cmd.nMode   = htonl(0x0012);
	strcpy(cmd.szIssuer,    SERVER_NAME);
	strcpy(cmd.szServiceId, serviceId);
	cmd.nLength = htonl((u_long)strlen(szAuth));

	// create socket
	if (isalpha(pszHost[0])) {
		struct hostent *phe = gethostbyname(pszHost);
		if (!phe)
			goto EXIT_FUNCTION;

		memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
	}
	else
		sa.sin_addr.s_addr = inet_addr(pszHost);

	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
		goto EXIT_FUNCTION;

	sa.sin_family      = AF_INET;
//	sa.sin_addr.s_addr = inet_addr(pszHost);
	sa.sin_port        = htons(RESOURCE_PORT);
	
	/* Elenoa MOD : START */
#ifdef _WIN32
	__nonblock_win32(sock);  

	if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
	{

		if (WSAEWOULDBLOCK == WSAGetLastError())
		{
			fd_set wfd, efd;
			struct timeval tv;
			int result;
			FD_ZERO(&wfd);
			FD_ZERO(&efd);
			FD_SET(sock, &wfd);
			FD_SET(sock, &efd);
			tv.tv_sec = timeout;
			tv.tv_usec = 0;
			result = select(0, 0, &wfd, &efd,&tv);
			if (SOCKET_ERROR == result || 0 == result)
			{
				int nRet = WSAGetLastError();
				goto EXIT_FUNCTION;
			}
		}
		else
			goto EXIT_FUNCTION;
	}

#else
    __nonblock(sock);
	{
		int i;
		for (i = 0; i < (timeout * 10); i++) {
			if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
				errno = 0;
				break;
			}
			if (errno == EISCONN)
				break;

			if (((i + 1) % 10) == 0)
			{
				shutdown(sock, 2);
				close(sock);
			}
			usleep(100000);
			//fprintf(stderr, "%d\n", i);
		}

		if (errno != EISCONN && errno != 0)
			goto EXIT_FUNCTION;
 	}
#endif

	// Send packet
	if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	if (_sh_send(sock, szAuth, (int)strlen(szAuth)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	cmd.nLength = ntohl(cmd.nLength);
	cmd.nResult = ntohl(cmd.nResult);
	if (cmd.nResult != 0x1000) {
		if (cmd.nResult == 0x3000)
			SetLastError(SHERRNO_UNDEFINED);
		else if (cmd.nResult == 0x3001)
			SetLastError(SHERRNO_AUTHORIZATION);
		else if (cmd.nResult == 0x9000)
			SetLastError(SHERRNO_INTERNAL);
		goto EXIT_FUNCTION;
	}

	if (_sh_recv(sock, szRecvBuf, cmd.nLength) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	closesocket(sock);
	sock = INVALID_SOCKET;

	pszUsedSpace = strchr(szRecvBuf, DELIMITER);
	*(pszUsedSpace++) = (char)NULL;

#ifdef WIN32
	*totalSpace = _atoi64(szRecvBuf);
	*freeSpace  = *totalSpace - _atoi64(pszUsedSpace);
#else
	*totalSpace = strtoll(szRecvBuf, NULL, 10);
	*freeSpace  = *totalSpace - strtoll(pszUsedSpace, NULL, 10);
#endif

	nResult = 1;

EXIT_FUNCTION:
	i = GetLastError();

	if (pszHost)
		free(pszHost);

	if (sock != INVALID_SOCKET)
		closesocket(sock);

//	ne_sock_exit();

	SetLastError(i);

	return nResult;
}

LPTRANSFER_LOG_DATA sh_get_transfer_log_list(const char *userId, const char *password, const char *serviceId,
											 const char* szSessionID,time_t sTime, time_t eTime,int nDelete,int nDirection)
{

	LPTRANSFER_LOG_DATA pLogFirst=NULL;
	// define varialbles

	char      szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256];
	__int64   nRandom;
	struct tm *ptmNow = NULL;
	time_t    tmtNow;
#ifdef WIN32
	char*	pdata;
#endif
	struct transfer_log_data tld;
    COMMAND_STRUCT cmd;
	int  i,nRet;
	LPTRANSFER_LOG_DATA pLogPrev=NULL;
	struct get_transfer_log gtl;
	
	SOCKET sock = INVALID_SOCKET;
	struct sockaddr_in sa; 
	char*	pszBody=NULL;
	char*	pszBuffer;
	char   szHost[30];
#ifdef WIN32
	FILE*	file;
#endif

	// get current time & random number

	//printf("Get Time from %s : start\n",SNTP_DOMAIN);
	tmtNow = get_time_from_sntp();
	//printf("Get Time from %s : end\n",SNTP_DOMAIN);

	srand((unsigned int)tmtNow);
	nRandom = rand() * rand();

	ptmNow = gmtime((const time_t *)&tmtNow);

	tmtNow  %= 10000000000;	// MAX 10
	nRandom %= 10000000000;	// MAX 10

	// create command struct
#ifdef WIN32
	sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#else
	sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#endif
	ne_md5_buffer(szMD5, szVerifyKey);

	ne_md5_buffer(password, szPassword);
	sprintf(szMD5, "%s%s%d", userId, szPassword, (int)tmtNow);
	ne_md5_buffer(szMD5, szPassword);

	sprintf(szAuth, "%s%c%s%c%d", userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow);

	// Make header

#ifdef WIN32
	memset((void *)&cmd, NULL, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
#else
	memset((void *)&cmd, 0, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
#endif
		ptmNow->tm_year + 1900, ptmNow->tm_mon, ptmNow->tm_wday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,
		szVerifyKey, (int)tmtNow, nRandom);

	cmd.nMode   = htonl(MSG_MODE_SSDK_GTS_GET_TRANSFER_LOG);
	strcpy(cmd.szIssuer,    SERVER_NAME);
	cmd.nLength = htonl((u_long)strlen(szAuth)+sizeof(gtl));

	switch(nDirection)
	{
	case 0: // upload
		gtl.direction = 'U';
		break;
	case 1: // download
		gtl.direction = 'D';
		break;
	default: // both
		gtl.direction = 'B';
		break;
	}

	gtl.enddate = ntohl((u_long)eTime);
	gtl.startdate = ntohl((u_long)sTime);
	
	if(nDelete ==0)
		gtl.is_delete = 'N';
	else
		gtl.is_delete = 'Y';

	ne_md5_buffer(szSessionID,gtl.sessionkey);
	//fprintf(stderr, "%s\n", gtl.sessionkey);
	strcpy(gtl.volumeid,serviceId);

	// create socket
	strcpy(szHost, CENTER_HOST);
	if (isalpha(szHost[0])) {
		struct hostent *phe = gethostbyname(szHost);
		if (!phe)
			goto EXIT_FUNCTION;

		memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
	}
	else
		sa.sin_addr.s_addr = inet_addr(szHost);

	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
		goto EXIT_FUNCTION;


	sa.sin_family      = AF_INET;
	sa.sin_port        = htons(GTLLOG_PORT);
	
	/* Elenoa MOD : START */
#ifdef _WIN32
	__nonblock_win32(sock);  

	if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
	{

		if (WSAEWOULDBLOCK == WSAGetLastError())
		{
			fd_set wfd, efd;
			struct timeval tv;
			int result;
			FD_ZERO(&wfd);
			FD_ZERO(&efd);
			FD_SET(sock, &wfd);
			FD_SET(sock, &efd);
			tv.tv_sec = timeout;
			tv.tv_usec = 0;
			result = select(0, 0, &wfd, &efd,&tv);
			if (SOCKET_ERROR == result || 0 == result)
			{
				int nRet = WSAGetLastError();
				goto EXIT_FUNCTION;
			}
		}
		else
			goto EXIT_FUNCTION;
	}

#else
    __nonblock(sock);
	{
		int i;
		for (i = 0; i < (timeout * 10); i++) {
			if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
				errno = 0;
				break;
			}
			if (errno == EISCONN)
				break;

			if (((i + 1) % 10) == 0)
			{
				shutdown(sock, 2);
				close(sock);
				if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
					goto EXIT_FUNCTION;
			}
			usleep(100000);
			//fprintf(stderr, "%d\n", i);
		}

		if (errno != EISCONN && errno != 0)
			goto EXIT_FUNCTION;
 	}
#endif
	
	if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	pszBody = (char*)malloc(strlen(szAuth)+sizeof(gtl));
	strcpy(pszBody,szAuth);
	memcpy(pszBody+strlen(szAuth),&gtl,sizeof(gtl));

	if (_sh_send(sock, pszBody,(int)strlen(szAuth)+sizeof(gtl)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;
/*
	if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	cmd.nLength = ntohl(cmd.nLength);
	cmd.nResult = ntohl(cmd.nResult);
	if (cmd.nResult != 0x1000) {
		if (cmd.nResult == 0x3000)
			SetLastError(SHERRNO_UNDEFINED);
		else if (cmd.nResult == 0x3001)
			SetLastError(SHERRNO_AUTHORIZATION);
		else if (cmd.nResult == 0x9000)
			SetLastError(SHERRNO_INTERNAL);
		goto EXIT_FUNCTION;
	}
*/
	tld.total_message_number = 0;
	i = 1;

	do
	{
		//fprintf(stderr, "WAIT TO RECEIVE HEADER\n");
		if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
			goto EXIT_FUNCTION;

		cmd.nLength = ntohl(cmd.nLength);
		cmd.nResult = ntohl(cmd.nResult);
		cmd.nMode = ntohl(cmd.nMode);

		if(cmd.nMode != MSG_MODE_GTS_SSDK_SEND_TRANSFER_LOG)
			goto EXIT_FUNCTION;
		
		if(cmd.nLength <=0 )
			goto EXIT_FUNCTION;
	
		pszBuffer = (char*)malloc(cmd.nLength);

		//fprintf(stderr, "WAIT TO RECEIVE BODY\n");
		if (_sh_recv(sock, pszBuffer,cmd.nLength) == SOCKET_ERROR)
			goto EXIT_FUNCTION;

		memcpy(&tld.total_message_number,pszBuffer,sizeof(int));
		memcpy(&tld.current_message_number,pszBuffer + sizeof(tld.total_message_number),sizeof(tld.current_message_number));
		memcpy(tld.sessionid,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number),sizeof(tld.sessionid));
		memcpy(tld.filename,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
			sizeof(tld.sessionid),sizeof(tld.filename));
		memcpy(&tld.length,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
			sizeof(tld.sessionid) + sizeof(tld.filename),sizeof(tld.length));
		memcpy(&tld.startdate,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
			sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length),sizeof(tld.startdate));
		memcpy(&tld.enddate,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
			sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length) + sizeof(tld.startdate),sizeof(tld.enddate));
		memcpy(&tld.respcode,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
			sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length) + sizeof(tld.startdate) + sizeof(tld.enddate), sizeof(tld.respcode));
		memcpy(&tld.direction,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
			sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length) + sizeof(tld.startdate) + sizeof(tld.enddate) + sizeof(tld.respcode),sizeof(tld.direction));

		free(pszBuffer);

		tld.total_message_number = ntohl(tld.total_message_number);
		tld.current_message_number = ntohl(tld.current_message_number);
		tld.enddate = ntohl(tld.enddate);
		tld.startdate = ntohl((u_long)tld.startdate);
		tld.respcode = ntohl((u_long)tld.respcode);

		//fprintf(stderr, "GET ONE\n");

		if(tld.total_message_number == 0)
			goto EXIT_FUNCTION;

		{
#if 0 // Elenoa: OLD CODE
		cmd.nMode   = htonl(MSG_MODE_SSDK_GTS_SEND_TRANSFER_LOG_RESP);
		strcpy(cmd.szIssuer,    SERVER_NAME);
		strcpy(cmd.szServiceId, serviceId);
		cmd.nLength = htonl(sizeof(int));

		if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
			goto EXIT_FUNCTION;
	
		nRet = htonl(0);

		if (_sh_send(sock, (char*)&nRet, sizeof(int)) == SOCKET_ERROR)
			goto EXIT_FUNCTION;
#endif
		PCOMMAND_STRUCT pcmd;
		char sendbuf[512];

		memset(sendbuf, 0, 511);
		pcmd = sendbuf;
		pcmd->nMode   = htonl(MSG_MODE_SSDK_GTS_SEND_TRANSFER_LOG_RESP);
		strcpy(pcmd->szIssuer,    SERVER_NAME);
		strcpy(pcmd->szServiceId, serviceId);
		pcmd->nLength = htonl(sizeof(int));
		*((int *)(sendbuf + sizeof(COMMAND_STRUCT))) = htonl(0);

		if (_sh_send(sock, (char *)pcmd, sizeof(COMMAND_STRUCT) + sizeof(int)) == SOCKET_ERROR)
			goto EXIT_FUNCTION;
		}
		//fprintf(stderr, "SEND RESEND\n");
		{
		LPTRANSFER_LOG_DATA pLog;
		pLog = (LPTRANSFER_LOG_DATA)malloc(sizeof(TRANSFER_LOG_DATA));

		if(!pLogFirst)
			pLogFirst = pLog;
		else
			pLogPrev->pnext = pLog;

		pLog->sessionid = (char*)malloc(TL_SESSION+1);
		pLog->filename = (char*)malloc(TL_FILENAME+1);
		pLog->pnext = NULL;
		pLogPrev = pLog;
		
		switch(tld.direction)
		{
		case 'u': case 'U':
            pLog->ndirection = 0;
			break;
		case 'd': case 'D':
			pLog->ndirection = 1;
			break;
		default:
			pLog->ndirection = 2;
			break;
		}
		strcpy(pLog->sessionid,tld.sessionid);
		strcpy(pLog->filename,tld.filename);
		pLog->enddate = tld.enddate;
		pLog->length = tld.length;
		pLog->startdate = tld.startdate;
		//fprintf(stderr, "LOOP\n");
		}
		i++;
	}while(i <= tld.total_message_number);

EXIT_FUNCTION:
	//fprintf(stderr, "ABOUT TO EXIT FUNCTION\n");

	if (sock != INVALID_SOCKET)
		closesocket(sock);
	
	if(pszBody)
		free(pszBody);

	return pLogFirst;
}

void sh_free_transfer_log(LPTRANSFER_LOG_DATA ploglist)
{
	LPTRANSFER_LOG_DATA pLogNext;

	if (!ploglist)
		return;

	pLogNext = ploglist->pnext;

	while(pLogNext)
	{
		pLogNext = ploglist->pnext;
		free(ploglist->sessionid);
		free(ploglist->filename);
		free(ploglist);
		ploglist = pLogNext;
	}
}


const char* sh_get_uri_by_filename(const char* szHost, const char *userId, const char *password,
								   const char* uri,int ncount, int nexpire)
{
	// define varialbles
	char* pszResult = NULL;

	char      szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256],szTemp[256];
	__int64   nRandom;
	struct tm *ptmNow = NULL;
	struct tm *ptmexpire = NULL;
	time_t    tmtNow;
	time_t texpire;

	COMMAND_STRUCT cmd;

	char *pszRecvBuf=NULL;

	SOCKET sock = INVALID_SOCKET;
	struct sockaddr_in sa; 

	if (ne_sock_init() != NE_OK)
		return NULL;

	if (szHost == NULL)
		return pszResult;

	// get current time & random number
	tmtNow = get_time_from_sntp();

//	tmtNow = time(NULL);

	srand((unsigned int)tmtNow);
	nRandom = rand() * rand();

	ptmNow = gmtime((const time_t *)&tmtNow);
	
	tmtNow  %= 10000000000;	// MAX 10
	nRandom %= 10000000000;	// MAX 10

	// create command struct
#ifdef WIN32
	sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#else
	sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
#endif
	ne_md5_buffer(szMD5, szVerifyKey);
	
	sprintf(szTemp,"%saFH ;WQGFVKHJFIUW-Odxfhwqg5ogh	p[wv,m'vbonniqpf2yr89cyf",password);

	ne_md5_buffer(szTemp, szPassword);
	
	texpire = get_time_from_sntp() + nexpire * 24 * 60 * 60;
	ptmexpire = gmtime((const time_t *)&texpire);

	sprintf(szAuth, "%s@%s%c%s%c%d%c%s%c%d%c%04d-%02d-%02d", userId, userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow,
		DELIMITER,uri,DELIMITER,ncount,DELIMITER,ptmexpire->tm_year + 1900,ptmexpire->tm_mon+1,ptmexpire->tm_mday);

	// Make header
#ifdef WIN32
	memset((void *)&cmd, NULL, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
#else
	memset((void *)&cmd, 0, sizeof(cmd));
	sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
#endif
	 ptmNow->tm_year + 1900, ptmNow->tm_mon+1, ptmNow->tm_mday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,szVerifyKey, (int)tmtNow, nRandom);
	
	cmd.nMode   = htonl(MSG_MODE_GET_FILE_NAME);
	strcpy(cmd.szIssuer,    SERVER_NAME);
	strcpy(cmd.szServiceId, userId);
	cmd.nLength = htonl((u_long)strlen(szAuth));

	// create socket
	if (isalpha(szHost[0])) {
		struct hostent *phe = gethostbyname(szHost);
		if (!phe)
			goto EXIT_FUNCTION;

		memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
	}
	else
		sa.sin_addr.s_addr = inet_addr(szHost);

	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
		goto EXIT_FUNCTION;

	sa.sin_family      = AF_INET;
	sa.sin_port        = htons(RESOURCE_PORT);
	
	/* Elenoa MOD : START */
#ifdef _WIN32
	__nonblock_win32(sock);  

	if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
	{

		if (WSAEWOULDBLOCK == WSAGetLastError())
		{
			fd_set wfd, efd;
			struct timeval tv;
			int result;
			FD_ZERO(&wfd);
			FD_ZERO(&efd);
			FD_SET(sock, &wfd);
			FD_SET(sock, &efd);
			tv.tv_sec = timeout;
			tv.tv_usec = 0;
			result = select(0, 0, &wfd, &efd,&tv);
			if (SOCKET_ERROR == result || 0 == result)
			{
				int nRet = WSAGetLastError();
				goto EXIT_FUNCTION;
			}
		}
		else
			goto EXIT_FUNCTION;
	}

#else
    __nonblock(sock);
	{
		int i;
		for (i = 0; i < (timeout * 10); i++) {
			if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
				errno = 0;
				break;
			}
			if (errno == EISCONN)
				break;

			if (((i + 1) % 10) == 0)
			{
				shutdown(sock, 2);
				close(sock);
			}
			usleep(100000);
			//fprintf(stderr, "%d\n", i);
		}

		if (errno != EISCONN && errno != 0)
			goto EXIT_FUNCTION;
 	}
#endif

	// Send packet
	if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	if (_sh_send(sock, szAuth, (int)strlen(szAuth)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	cmd.nLength = ntohl(cmd.nLength);
	cmd.nResult = ntohl(cmd.nResult);
	if (cmd.nResult != 0x1000)
	{
		SetLastError(cmd.nResult);
		goto EXIT_FUNCTION;
	}

	pszRecvBuf = (char*)malloc(cmd.nLength+1);
	memset(pszRecvBuf,0x00,cmd.nLength+1);

	if (_sh_recv(sock, pszRecvBuf, cmd.nLength) == SOCKET_ERROR)
		goto EXIT_FUNCTION;

	closesocket(sock);
	sock = INVALID_SOCKET;

	SetLastError(GetLastError());

EXIT_FUNCTION:
	if (sock != INVALID_SOCKET)
		closesocket(sock);

	return pszRecvBuf;
}

#ifndef WIN32
void SetLastError(int nErrCode)
{
	errno = nErrCode;
}

#endif

/* Elenoa MOD START */
static int _sh_send(SOCKET s, char *pszBuf, int nLen)
{
	int iSent = 0, nSentLen;
	fd_set wset;
	struct timeval tv;

	FD_ZERO(&wset);
	FD_SET(s, &wset);
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	do {
		if (select(s + 1, NULL, &wset, NULL, &tv) < 0) break;
		if (!FD_ISSET(s, &wset)) break;

		nSentLen = send(s, pszBuf + iSent, nLen, 0);

		iSent += nSentLen;
		nLen  -= nSentLen;
	} while (nLen > 0 && nSentLen > 0);

	return nLen > 0 ? SOCKET_ERROR : iSent;
}

static int _sh_recv(SOCKET s, char *pszBuf, int nLen)
{
	int iRecv = 0, nRecvLen;
	fd_set rset;
	struct timeval tv;
	int nRet;

	FD_ZERO(&rset);
	FD_SET(s, &rset);
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	do {
		nRet = select(s + 1, &rset, NULL, NULL, &tv);
		
		if (nRet <= 0)
		{
			break;
		}
		if (!FD_ISSET(s, &rset)) break;

		nRecvLen = recv(s, pszBuf + iRecv, nLen, 0);

		iRecv += nRecvLen;
		nLen  -= nRecvLen;
	} while (nLen > 0 && nRecvLen > 0);

	return nLen < 0 ? SOCKET_ERROR : iRecv;
}


void sh_set_cache_file(const char *file_path)
{
	strncpy(szCacheFile,file_path,sizeof(szCacheFile));
}

/* Elenoa MOD END */
/* Original CODE START *
static int _sh_send(SOCKET s, char *pszBuf, int nLen)
{
	int iSent = 0, nSentLen;
	fd_set wset;

	do {
		nSentLen = send(s, pszBuf + iSent, nLen, 0);

		iSent += nSentLen;
		nLen  -= nSentLen;
	} while (nLen > 0 && nSentLen > 0);

	return nLen > 0 ? SOCKET_ERROR : iSent;
}
*/
/*
static int _sh_recv(SOCKET s, char *pszBuf, int nLen)
{
	int iRecv = 0, nRecvLen;
	do {
		nRecvLen = recv(s, pszBuf + iRecv, nLen, 0);

		iRecv += nRecvLen;
		nLen  -= nRecvLen;
	} while (nLen > 0 && nRecvLen > 0);

	return nLen < 0 ? SOCKET_ERROR : iRecv;
}
* Original CODE END */