#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#include "TSServer.h"

#ifdef TS_USE_MFC
#else

#ifndef TS_USE_WINSOCK
#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
#include "da.h" /* Debugging allocator -- GDR 2000-09-01 */

BOOL CSocket::Create(unsigned int socketPort, int socketType,
	const char *socketAddress)
{
	if (Socket(socketType))
	{
		if (Bind(socketPort,socketAddress))
			return TRUE;
#ifdef TS_USE_WINSOCK
		int result = GetLastError();
#endif
		Close();
#ifdef TS_USE_WINSOCK
		WSASetLastError(result);
#endif
	}
	return FALSE;

}
BOOL CSocket::Bind(unsigned int socketPort, const char *socketAddress)
{
	SOCKADDR_IN sockAddr;
	memset(&sockAddr,0,sizeof(sockAddr));

	//LPSTR lpszAscii = T2A((LPTSTR)lpszSocketAddress);

	sockAddr.sin_family = AF_INET;

	if (socketAddress == NULL)
		sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else
	{
		unsigned long lResult = inet_addr(socketAddress);
		if (lResult == INADDR_NONE)
		{
#ifdef TS_USE_WINSOCK
			WSASetLastError(WSAEINVAL);
#endif
			return FALSE;
		}
		sockAddr.sin_addr.s_addr = lResult;
	}

	sockAddr.sin_port = htons((u_short)socketPort);

  return (SOCKET_ERROR != bind(m_hSocket, (SOCKADDR*)&sockAddr, sizeof(sockAddr)));
}
BOOL CSocket::Socket(int socketType,
	int protocolType, int addressFormat)
{
	m_hSocket = socket(addressFormat,socketType,protocolType);
	if (m_hSocket != INVALID_SOCKET)
	{
    return TRUE;
	}
  return FALSE;
}

BOOL CSocket::Connect(const char *hostAddress, unsigned int portNumber)
{
	SOCKADDR_IN sockAddr;
	memset(&sockAddr,0,sizeof(sockAddr));

	//LPSTR lpszAscii = T2A((LPTSTR)hostAddress);
	sockAddr.sin_family = AF_INET;
	sockAddr.sin_addr.s_addr = inet_addr(hostAddress);

	if (sockAddr.sin_addr.s_addr == INADDR_NONE)
	{
		LPHOSTENT lphost;
		lphost = gethostbyname(hostAddress);
		if (lphost != NULL)
			sockAddr.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
		else
		{
#ifdef TS_USE_WINSOCK
			WSASetLastError(WSAEINVAL);
#endif
			return FALSE;
		}
	}

	sockAddr.sin_port = htons((u_short)portNumber);

	return Connect((SOCKADDR*)&sockAddr, sizeof(sockAddr));
}
BOOL CSocket::Connect(const SOCKADDR* lpSockAddr, int sockAddrLen)
{
	if (connect(m_hSocket, lpSockAddr, sockAddrLen) == SOCKET_ERROR)
	{
		return FALSE;
	}
	return TRUE;
}
void CSocket::Close()
{
#ifdef WIN32
  closesocket(m_hSocket);
#else
  close(m_hSocket);
#endif
}
int CSocket::Send(const void* lpBuf, int nBufLen, int nFlags)
{
	int nLeft, nWritten;
	char *pBuf = (char *)lpBuf;
	nLeft = nBufLen;

	while (nLeft > 0)
	{
		nWritten = send(m_hSocket, (const char*)lpBuf, nBufLen, nFlags);
		if (nWritten == SOCKET_ERROR)
			return nWritten;

		nLeft -= nWritten;
		pBuf += nWritten;
	}
	return nBufLen - nLeft;
}
int CSocket::Receive( void* lpBuf, int nBufLen, int nFlags)
{
  return recv(m_hSocket, (char*)lpBuf, nBufLen, nFlags);
}
int CSocket::GetLastError()
{
#ifdef WIN32
  return WSAGetLastError();
#else
  return errno;
#endif
}
#endif

TSSocket::TSSocket()
{
  socketBufferSize = 2048;
  connected = FALSE;
  Initialize();
}
TSSocket::~TSSocket()
{
  if(connected)
  {
    Close();
  }
  if(socketBuffer) free(socketBuffer);
}
BOOL TSSocket::Create( unsigned int socketPort, int socketType, char * socketAddress)
{
  bufferStart = bufferEnd = 0;
  return CSocket::Create(socketPort, socketType, socketAddress);
}
void TSSocket::Initialize()
{
  bufferStart = bufferEnd = 0;
  socketBuffer = (char*)malloc(socketBufferSize);
}
BOOL TSSocket::Connect( const char *hostAddress, unsigned int portNumber )
{
  BOOL tmp = CSocket::Connect(hostAddress, portNumber);
  if(tmp)
  {
    connected = TRUE;
  }

  return tmp;
}
// This works just like fread except that the \n are
// stripped off because that's what's convenient for
// out uses.
int TSSocket::ReadLine(char *buffer, int size)
{
  
  for(int ii = 0; ii < size; ii++)
  {
    if(bufferStart == bufferEnd)
    {
      if(FillBuffer() == 0) return ii-1;
    }

    if(socketBuffer[bufferStart] == '\r')
    {
      bufferStart++;
      ii--;
      continue;
    }
    else if(socketBuffer[bufferStart] == '\n')
    {
      bufferStart++;
      if(ii < size) buffer[ii] = '\0';
      return ii;
    }

    buffer[ii] = socketBuffer[bufferStart];
    bufferStart++;

  }
  return size;
}
int TSSocket::Read(char *buffer, int size)
{

  int bufferSize = bufferEnd-bufferStart;
  if(bufferSize == size)
  {
    memcpy(buffer, socketBuffer, size);
    bufferStart = bufferEnd = 0;
    return size;
  }
  else if (bufferSize < size)
  {
    if(bufferSize != 0)
    {
      memcpy(buffer, socketBuffer, bufferSize);
      bufferStart = bufferEnd = 0;
    }
    if(FillBuffer() > 0)
      return bufferSize + Read(buffer+bufferSize,size-bufferSize);
    else
      return bufferSize;
  }
  else // bufferSize > size
  {
    memcpy(buffer, socketBuffer, size);
    bufferStart += size;
    return size;
  }

}
char TSSocket::ReadChar()
{
  if(bufferStart == bufferEnd)
  {
    if(FillBuffer() == 0) return 0;
  }
  return socketBuffer[bufferStart++];
}
int TSSocket::FillBuffer()
{
  if(bufferStart != bufferEnd) return 0;

  bufferStart = 0;
  bufferEnd = Receive(socketBuffer, socketBufferSize, 0);
  if(bufferEnd == SOCKET_ERROR)
  {
    return 0;
  }

  return bufferEnd;
}
int TSSocket::ReceiveInt(int *val)
{
  char ch;
  TSString buf = "";
  *val = 0;

  while ( (ch = ReadChar()) != 0)
  {
    if (ch == '\n' || ch == '\r' || ch == ',')
      break;

    buf += ch;
  }

  if (buf == "")
    return(TS_ERROR);

  *val = atol(buf.GetBuffer());

  return TS_OK;
}
int TSSocket::ReceiveDouble(double *val)
{
  char ch;
  TSString buf = "";

  *val = 0.0;

  while ((ch = ReadChar()) != 0)
  {
    if (ch == '\n' || ch == '\r' || ch == ',')
      break;

    if (ch == '$')
    {
      char temp[3];

      if ((temp[0] = ReadChar()) == 0)
        return TS_OK;

      if ((temp[1] = ReadChar()) == 0)
        return TS_OK;

      temp[2] = '\0';

      int charVal;
      sscanf(temp, "%x", &charVal);
      buf += (char)charVal;
    }
    else
      buf += ch;
  }

  if (buf == "")
    return TS_ERROR;

  *val = strtod(buf.GetBuffer(),NULL);

  return TS_ERROR;
}
int TSSocket::ReceiveString(char *str, int size)
{
  TSString tmp;
  ReceiveString(&tmp);
  strncpy(str,tmp.GetBuffer(),size);

  return TS_OK;
}
int TSSocket::ReceiveString(TSString *str)
{
  char ch;

  if ((ch = ReadChar()) == 0)
    return TS_ERROR;

  if (ch == '\r' || ch == '\n')
  {
    ReadChar();
    return TS_ERROR;
  }

  if (ch != '"')
    return TS_ERROR;

  while ((ch = ReadChar()) != 0)
  {
    if (ch == '"')
    {
      ReadChar(); // Read the separating comma
      return TS_OK;
    }

    if (ch == '$')
    {
      char temp[3];

      if ((temp[0] = ReadChar()) == 0)
        return TS_OK;

      if ((temp[1] = ReadChar()) == 0)
        return TS_OK;

      temp[2] = '\0';

      int val;
      sscanf(temp, "%x", &val);
      (*str) += (char)val;
    }
    else
      (*str) += ch;
  }

  return(TRUE);

}

// Encode's a string to be sent through the web server
// enclosed in quotes.
void TSEncodeString(TSString &in, TSString &out)
{
  char encode[16];
  char *p = in.GetBuffer();

  // Write starting quote
  out = "\"";

  // Write each character
  while (*p)
  {
    if (isalnum(*p) || *p == '-' ||
        *p == '_' || *p == '.' || *p == 13 || *p == 10)
    {
      out += (*p);
    }
    else
    {
      sprintf(encode,"$%x", *p);
      out += encode;
    }

    p++;
  }

  // Write closing quote and comma
  out += "\",";

}
void TSEncodeString(const char *in, TSString &out)
{
  static TSString tmp;

  if (in == NULL)
    tmp = "";
  else
    tmp = in;

  TSEncodeString(tmp,out);
}
// Encode's a string to be sent through the web server,
// but doesn't enclose it in quotation marks.
void TSEncodeText(const char *in, TSString &out)
{
  static TSString tmp;
  
  tmp = in;

  TSEncodeText(tmp,out);
}
void TSEncodeText(TSString &in, TSString &out)
{
  char encode[16];
  char * p = in.GetBuffer();

  out = "";

  while (*p)
  {
    if (isalnum(*p) || *p == '-' ||
        *p == '_' || *p == '.' || *p == 13 || *p == 10)
    {
      out += (*p);
    }
    else
    {
      sprintf(encode,"$%x", *p);
      out += encode;
    }
    p++;
  }
}
void TSEncodeInt(int in, TSString &out)
{
  static char tmp[24];
  sprintf(tmp,"%d,", in);
  out = tmp;
}
void TSEncodeDouble(double in, TSString &out)
{
  static char tmp[32];
  sprintf(tmp, "%.16g,", in);
  out = tmp;
}
#ifdef TS_USE_WINSOCK
int TSInitializeWinsock()
{
  /*
   * This is the Windows socket startup stuff to initialize the
   * Winsock DLL.
   */
#ifdef TS_USE_MFC
  if (!AfxSocketInit())
  {
    printf("Error intializing winsock!\n");
    return TS_ERROR;
  }
  printf("Winsock initialized\n");
#else
  WORD wVersionRequested;
  WSADATA wsaData;
  int err;
 
  wVersionRequested = MAKEWORD( 2, 2 );
 
  err = WSAStartup( wVersionRequested, &wsaData );
  if ( err != 0 ) {
      return TS_ERROR;
  }
#endif

  return TS_OK;
}
#endif