/*******************************************************************\
| ezsockets.cpp: EzSockets Class Source                             |
|   Designed by Josh Allen, Charles Lohr and Adam Lowman.           |
|   Socket programming methods based on Charles Lohr's EZW progam.  |
|   Modified by Charles Lohr for use with Windows-Based OSes.       |
|   UDP/NON-TCP Support by Adam Lowman.                             |
\*******************************************************************/

#include "ezsockets.h"

#include "global.h" // StepMania only includes

#if defined(_XBOX)
#elif defined(_WINDOWS) // We need the WinSock32 Library on Windows
  #pragma comment(lib,"wsock32.lib")
#else
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <unistd.h>
  #include <arpa/inet.h>
#endif

EzSockets::EzSockets() {
  MAXCON = 5;
  memset (&addr,0,sizeof(addr)); //Clear the sockaddr_in structure

  #if defined(_WINDOWS) || defined(_XBOX) // Windows REQUIRES WinSock Startup
	 WSAStartup( MAKEWORD(1,1), &wsda );
  #endif

  sock = -1;
  blocking = true;
  scks = new fd_set;
  times = new timeval;
  times->tv_sec = 0;
  times->tv_usec = 0;
  state = skDISCONNECTED;
}

EzSockets::~EzSockets() {
  close();
  delete scks;
  delete times;
}

//Check to see if the socket has been created
bool EzSockets::check() {
  return(sock>0);
}

bool EzSockets::create() {
  return create(IPPROTO_TCP, SOCK_STREAM);
}

bool EzSockets::create(int Protocol) {
  switch(Protocol) {
    case IPPROTO_TCP:
	  return create(IPPROTO_TCP, SOCK_STREAM);
	case IPPROTO_UDP:
	  return create(IPPROTO_UDP, SOCK_DGRAM);
	default:
	  return create(Protocol, SOCK_RAW);
  }
}

bool EzSockets::create(int Protocol, int Type) {
  state = skDISCONNECTED;
  sock = socket(AF_INET, Type, Protocol);
  return(sock>0);
}


bool EzSockets::bind(unsigned short port) {
  if(!check())
	return false;

  addr.sin_family      = AF_INET;
  addr.sin_addr.s_addr = htonl(INADDR_ANY);
  addr.sin_port        = htons(port);
  
  return(::bind(sock,(struct sockaddr*)&addr, sizeof(addr))==0);
}

bool EzSockets::listen() {
  if(::listen(sock,MAXCON)!=0)
	return false;

  state = skLISTENING;
  return true;
}

/************************************************************************\
| To whomever edited this:                                               |
|   Please do not assume LINUX is defined if you're compiling on Linux!  |
|   It will not compile properly.                                        |
\************************************************************************/
#if defined(WIN32) || defined(DARWIN) // glibc already has socklen_t defined
  typedef int socklen_t;
#endif

bool EzSockets::accept(EzSockets &socket) {
  int length = sizeof(socket);

  socket.sock = ::accept(sock,(struct sockaddr*) &socket.addr,(socklen_t*) &length);

  if(socket.sock<=0)
	return false;
  
  socket.state = skCONNECTED;
  return true;
}

void EzSockets::close() {
  state = skDISCONNECTED;
  inBuffer = "";
  outBuffer = "";

  #if defined(WIN32) // The close socket command is different in Windows
	::closesocket(sock);
  #else
	::close(sock);
  #endif
}

long EzSockets::uAddr() {
  return addr.sin_addr.s_addr;
}


bool EzSockets::connect(const std::string& host,unsigned short port) {
  if(!check())
	return false;

  #if defined(_XBOX)
	// FIXME: Xbox doesn't have gethostbyname or any way to get a hostent.  
	// Investigate the samples and figure out how this is supposed to work.
	return false;
  #elif defined(_WINDOWS)
	struct hostent* phe;
	phe = gethostbyname(host.c_str());
    addr.sin_addr = *((LPIN_ADDR)* phe->h_addr_list);
  #else
	inet_pton(AF_INET,host.c_str(),&addr.sin_addr);
  #endif 
  addr.sin_family = AF_INET;
  addr.sin_port   = htons(port);

  if(::connect(sock,(struct sockaddr*)&addr,sizeof(addr))!=0)
    return false;

  state = skCONNECTED;
  return true;
}

bool EzSockets::CanRead() {
  FD_ZERO(scks);
  FD_SET((unsigned)sock,scks);

  return(select(sock+1,scks,NULL,NULL,times)>0);
}

bool EzSockets::IsError() {
  if(state==skERROR)
	return true;

  FD_ZERO(scks);
  FD_SET((unsigned)sock,scks);

  if(select(sock+1, NULL, NULL, scks, times)>=0)
	return false;

  state=skERROR;
  return true;
}

bool EzSockets::CanWrite() {
  FD_ZERO(scks);
  FD_SET((unsigned)sock,scks);

  return(select(sock+1,NULL,scks,NULL,times)>0);
}

void EzSockets::update() {
  if(IsError()) //If socket is in error, don't bother.
	return;

  while(CanRead() && !IsError()) //Check for Reading
	if(pUpdateRead()<1)
	  break;

  if(CanWrite() && (outBuffer.length()>0))
    pUpdateWrite();
}


/*********************\
|   Raw Data System   |
\*********************/
void EzSockets::SendData(string &outData) {
  outBuffer.append(outData);
  if(blocking)
	while ((outBuffer.length()>0) && !IsError())
	  pUpdateWrite();
  else
	update();
}

void EzSockets::SendData(const char* data,unsigned int bytes) {
  outBuffer.append(data,bytes);
  if(blocking)
	while ((outBuffer.length()>0) && !IsError())
	  pUpdateWrite();
  else
	update();
}

int EzSockets::ReadData(char* data,unsigned int bytes) {	
  int bytesRead = PeekData(data,bytes);
  inBuffer = inBuffer.substr(bytesRead);
  return bytesRead;
}

int EzSockets::PeekData(char* data,unsigned int bytes) {
  if(blocking)
	while ((inBuffer.length()<bytes) && !IsError())
	  pUpdateRead();
  else
	while (CanRead() && !IsError())
      if (pUpdateRead()<1)
		break;

  int bytesRead = bytes;
  if(inBuffer.length()<bytes)
    bytesRead = inBuffer.length();
  memcpy(data,inBuffer.c_str(),bytesRead);

  return bytesRead;
}


/**********************************\
|   Packet/Structure Data System   |
\**********************************/
void EzSockets::SendPack(char* data,unsigned int bytes) {
  unsigned int SendSize = htonl(bytes);
  SendData((char*)&SendSize,sizeof(int));
  SendData(data,bytes);
}

int EzSockets::ReadPack(char* data,unsigned int max) {
  int size = PeekPack(data,max);
  if(size!=-1)
	inBuffer=inBuffer.substr(size+4);

  return size;
}

int EzSockets::PeekPack(char* data,unsigned int max) {
  if(CanRead())
	pUpdateRead();

  if(blocking) {
	while((inBuffer.length()<4) && !IsError()) {
	  pUpdateRead();
	}
  
	if(IsError())
	  return -1;
  }

  if(inBuffer.length()<4)
	return -1;

  unsigned int size=0;
  PeekData((char*)&size,4);
  size=ntohl(size);

  if(blocking)
    while ((inBuffer.length()<(size+4)) && !IsError())
  	  pUpdateRead();
  else
    if((inBuffer.length()<(size+4)) || (inBuffer.length()<=4))
      return -1;

  string tBuff(inBuffer.substr(4,size));
  if(tBuff.length()>max)
    tBuff.substr(0,max);
  memcpy (data,tBuff.c_str(),tBuff.length());

  return size;
}


/*****************************************\
|   Null Terminating String Data System   |
\*****************************************/
void EzSockets::SendStr(string& data, char delim) {
  char tDr[1];
  tDr[0] = delim;
  SendData(data.c_str(),data.length());
  SendData(tDr,1);
}

int EzSockets::ReadStr(string& data, char delim) {
  int t = PeekStr(data,delim);
  if(t>=0)
	inBuffer = inBuffer.substr(t+1);
  return t;
}

int EzSockets::PeekStr(string& data, char delim) {
  int t = inBuffer.find(delim,0);
  if(blocking)	{
	while ((t==-1) && !IsError()) {
	  pUpdateRead();
	  t = inBuffer.find(delim,0);
	}
	data = inBuffer.substr(0,t);
  }

  if(t>=0)
    data = inBuffer.substr(0,t);
  return t;
}


/************************\
|   Stream Data System   |
\************************/
istream& operator >>(istream &is,EzSockets &obj) {
  string writeString;
  obj.SendStr(writeString);
  is >> writeString;
  return is;
}

ostream& operator <<(ostream &os, EzSockets &obj) {
  string readString;
  obj.ReadStr(readString);
  os << readString;
  return os;
}


/**************************\
|   Internal Data System   |
\**************************/
int EzSockets::pUpdateRead() {
  char tempData[1024];
  int bytes = pReadData(tempData);

  if(bytes>0)
	inBuffer.append(tempData,bytes);
  else if(bytes<0)
	state = skERROR;
  return bytes;
}

int EzSockets::pUpdateWrite() {
  int bytes = pWriteData(outBuffer.c_str(),outBuffer.length());

  if (bytes>0)
	outBuffer = outBuffer.substr(bytes);
  else if(bytes<0)
	state = skERROR;
  return bytes;
}


int EzSockets::pReadData(char* data) {
  if((state == skCONNECTED)||(state == skLISTENING))
    return recv(sock,data,1024,0);
  else {
	fromAddr_len = sizeof(sockaddr_in);
	return recvfrom(sock,data,1024,0,(sockaddr*)&fromAddr,(socklen_t*)&fromAddr_len);
  }
}

int EzSockets::pWriteData(const char* data,int dataSize) {
  return send(sock,data,dataSize,0);
}

/* 
 * (c) 2003-2004 Josh Allen, Charles Lohr, and Adam Lowman
 * All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */