#include "stdafx.h"
#include "windows.h"

#include "util_socket.h"


#include "mmsystem.h"
#include <stdio.h>
#include <WinSock2.h>


/*
  made by cjy

  Using nonblocking socket 


*/

int sock_connect(const char* ip, int port, int timeout_ms)
{

	int sock = socket(AF_INET, SOCK_STREAM, 0);
	if(sock == -1) 
	{
		return -1;
	}

	struct sockaddr_in addr;
	memset(&addr, 0x00, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = inet_addr(ip);


// connect, timeout support - cjy, 07_0403 12:53
	unsigned long ul=1;
	ioctlsocket(sock, FIONBIO, &ul);	// nonblocking
	//DWORD s1 = GetTickCount();
	int hr = connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr));
	if(hr != 0)
	{
		if(WSAGetLastError() != WSAEWOULDBLOCK)
		{
			return -5;
		}

	//	ASSERT(
	// non blocking socket
		// check connect
		fd_set	fdWrite, fdError;
		ZeroMemory(&fdWrite, sizeof(fd_set));
		ZeroMemory(&fdError, sizeof(fd_set));
		FD_ZERO(&fdWrite);
		FD_ZERO(&fdError);
		FD_SET((SOCKET)sock, &fdWrite);
		FD_SET((SOCKET)sock, &fdError);

		
		struct	timeval	tvTimeout;
		tvTimeout.tv_sec	= timeout_ms/1000;
		tvTimeout.tv_usec	= timeout_ms%1000*1000;

		{
			int ret = select(sock+1, NULL, &fdWrite, &fdError, &tvTimeout);
			//int ret = select(sock+1, NULL, &fdWrite, NULL, &tvTimeout);
			if(ret == 0)
			{
			// timeout!
				//TRACE("[DLL] %s Get Device Information Connect Error\n", ip);
				closesocket(sock);

				return -2;
			}
			if(ret == SOCKET_ERROR)
			{
//				TRACE("[DLL] %s Get Device Information Connect Select Error [ErrorCode:%d]\n", ip, WSAGetLastError());
				closesocket(sock);

				return -3;
			}

			if(FD_ISSET(sock, &fdError))
			{	// connect fail
				//TRACE("[DLL] %s Get Device Information Connect Error [ErrorCode:%d]\n", ip, WSAGetLastError());
				closesocket(sock);

				return -4;
			}

			if(WSAGetLastError() != ERROR_SUCCESS)
			{
				closesocket(sock);

				return -6;
			}
		}
	}

	return sock;
}

// 1 - read
// 0 - timeout
// -1 - socket error
//       -2 - select error
// -3 - socket error
int sock_wait_for_read(int sock, int timeout_ms)
{
// check response
	fd_set fdRead;	//, fdError;

	FD_ZERO(&fdRead);
	//FD_ZERO(&fdError);
	FD_SET((SOCKET)sock, &fdRead);
	//FD_SET((SOCKET)sock, &fdError);

// loop
	//int recv_total = 0;
	struct	timeval	tvTimeout;
	tvTimeout.tv_sec	= timeout_ms/1000;
	tvTimeout.tv_usec	= (timeout_ms%1000)*1000;

	//int ret = select(sock+1, &fdRead, NULL, &fdError, &tvTimeout);
	int ret = select(sock+1, &fdRead, NULL, NULL, &tvTimeout);
	if(ret == 0)
	{
		// timeout
		return 0;
	}
	if(ret == SOCKET_ERROR)
	{
		return -1;
	}

/*	if(FD_ISSET(sock, &fdError))
	{
		// error?
	//	closesocket(sock);
		return -2;
	}*/

//	if(FD_ISSET(sock, &fdRead))
//	{
//		// read
//		return 1;
//	}

	if(WSAGetLastError() != ERROR_SUCCESS)
	{
		return -3;
	}

	// success
	return 1;
}

// µ¥ÀÌÅÍ°¡ µµÂøÇÒ¶§±îÁö ÃÖ´ë timeout_ms½Ã°£±îÁö ±â´Ù·È´Ù°¡ 
int sock_recv_wait(int sock, char* buf, int max, int timeout_ms)
{

	int hr = sock_wait_for_read(sock, timeout_ms);
	switch(hr)
	{
	case 0:	//timeout
		return 0;

	case -1: //socket error
		return -1;

	case -2: //select error
		return -2;

	case 1:	// readable
		{
			int read = recv(sock, buf, max, 0);
			return read;
		}

	default:
		return 0;
	}
	
/*
// check response
	fd_set fdRead, fdError;

	FD_ZERO(&fdRead);
	FD_ZERO(&fdError);
	FD_SET(sock, &fdRead);
	FD_SET(sock, &fdError);

// loop
	//int recv_total = 0;
	struct	timeval	tvTimeout;
	tvTimeout.tv_sec	= timeout_ms/1000;
	tvTimeout.tv_usec	= (timeout_ms%1000)*1000;

	int ret = select(sock+1, &fdRead, NULL, &fdError, &tvTimeout);
	if(ret == 0)
	{
		// timeout
		return 0;
	}
	if(ret == SOCKET_ERROR)
	{
		return -2;
	}

	if(FD_ISSET(sock, &fdError))
	{
		// error?
		closesocket(sock);
		return -1;
	}

	if(FD_ISSET(sock, &fdRead))
	{
		// read
		int read = recv(sock, buf, max, 0);
		return read;
	}
	return 0;
*/

}


int sock_recv(int sock, char* buf, int size, int timeout_ms)
{
	
// loop
	int recv_total = 0;
	while(recv_total < size)
	{
		int read = sock_recv_wait(sock, buf+recv_total, size-recv_total, timeout_ms);
		if(read == 0)
		{	// timeout
			break;
		}

		if(read == -1)
		{	// socket error
			return -1;
		}

		if(read == -2)
		{	// select error
			return -2;
		}

		recv_total += read;
	}

	return recv_total;
}


// ÃÖ´ë timeout_ms½Ã°£µ¿¾È line¼ö¸¸Å­À» ¹Þ´Â´Ù.
int sock_recv_lines(int sock, char* buf, int max, int line, int timeout_ms)
{
	
// check response

// loop
	int recv_line = 0;
	int recv_total = 0;
	while(recv_total < max)
	{
		int read = sock_recv_wait(sock, buf+recv_total, max-recv_total, timeout_ms);
		if(read == 0)
		{	// timeout
			break;
		}

		if(read == -1)
		{	// socket error
			return -1;
		}

		if(read == -2)
		{	// select error
			return -2;
		}

		
		// line count
		for(int i = 0; i < read; ++i)
		{
			if(buf[recv_total+i] == '\n')
			{
				recv_line++;
			}
		}
		recv_total += read;


	// check recv line
		if(recv_line >= line)
			break;
	}
	buf[recv_total] = 0;

	return recv_total;
}


int sock_send_format(int sock, const char* fmt, ...)
{
	char buffer[1024];

	va_list ap;
	va_start(ap, fmt);
	int len = vsprintf(buffer, fmt, ap);
	va_end(ap);

	sock_send_loop(sock, buffer, strlen(buffer), 3000);

	return 1;
}


// return value
//	-1 : Disconnect socket while send the data
// > 0 : sent data size
int sock_send_loop(int sock, const char* buf, int size, DWORD timeout_ms)
{
	// send
	int total_send = 0;			// ÇöÀç Àü¼ÛÇÑ Å©±â
//	int remain_size = size;	// ³²Àº Àü¼ÛÇÒ Å©±â

	DWORD start, current;
	start = timeGetTime();

	while((current = timeGetTime()) - start < timeout_ms)
	{
		int remain_size = size - total_send;

		int sent = send(sock, (char *)buf+total_send, remain_size, 0);
		if(sent <= 0)
		{
			//fclose(fifo);
			int err = WSAGetLastError();
			if(err == 10035)
			{
				Sleep(1);
				continue;
			}

			return -1;	// µµÁß¿¡ Á¢¼ÓÀÌ ²÷±ä °æ¿ì
		}

		total_send += sent;

	// ÀüºÎ Àü¼ÛÇߴ°¡?
		if(total_send >= size)
		{
			return total_send;
		}

	}

// timeout
	return total_send;
}