SERVEUR POUR CLIENT TELNET [G++]

/***************************************************************************
                          main.cpp  -  description
                             -------------------
    begin                : Sat Nov 29 17:56:06 UTC 2003
    email                : admin@cxczone.com
    NO COPYRIGHT OPENSOURCE WILL BE THE COMPUTERS ' FUTUR
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 // au niveau de la définition des clients, il faudrait un random pour pouvoir avoir un serveur multiclient
 // ce problème, ainsi que d'autre fonctionnalité comme le cryptage md5 sera disponible dans la version 2.0
 //Des fonctions au serveur seront ajouter car là c'est un peu vide

 



#include <iostream.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <arpa/inet.h>
#include <unistd.h>

void version();


namespace var {     
int PORT, s, connection;
char *PASS = new char[6];
   struct sockaddr_in  saun;
}

class client {         //class client, qui contiendra les fonctions du serveur, et toutes les informations du client
public:
int registerclient(char *IP);
int veriflogin(char *PASST);
int quit();

//ICI on ajoute les fonctions du serveurs
private:
char *IPCLIENT;
int PORTCLIENT;
char *PASSCLIENT;
int GRANTED;

};


int main()
{
using var::s;
using var::connection;
using var::saun;
     version();
      cout << "\nPort : ";
      cin >> var::PORT;
      cout << "\nUsers'Pass : " ;
      cin >> var::PASS;

      system("clear");
      cout << "\nLancement du serveur...\n";


 //création de la socket
    if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
    perror("server: socket"); 
    exit(1);
    }

    //Definition de la connection
  saun.sin_family     = AF_INET;
  saun.sin_addr.s_addr = htonl(INADDR_ANY);
  saun.sin_port       = htons(var::PORT);

     if (bind(s, (struct sockaddr *) &saun, sizeof(saun)) < 0){
        perror("bind error");
        exit(1);
        }

        //on ecoute la connection
        
    if (listen(s, 5) < 0){

        perror("listen error");
        exit(1);
        }
          char b[] = "\nTelnetServer-1.0\n";             //message de bienvenue

         //On accepte la connection 
    if ((connection = accept(s, (struct sockaddr *) NULL, NULL)) < 0)   {


    perror("accept error"); //pareil que pour la haut, si sa merde sa dit quel est l'érreur
    exit(1);
       }
       
       send(connection,b,sizeof(b),0);

       
send(connection,inet_ntoa(saun.sin_addr),strlen(inet_ntoa(saun.sin_addr)),0);   //on envoi l'adresse ip du client

send(connection,"\n",sizeof("\n"),0);

 client client;  //c'est ici qu'il faudra changer quelque chose si nous voulons un serveur multi-client
 
 client.registerclient(inet_ntoa(saun.sin_addr));   //on enregistre le client

 cout << "\nUne connection de " << inet_ntoa(saun.sin_addr) ;
 cout << "\n";
 
 int out = 0;
 int verif = 0;
 char *buffer = new char[100];
 
do
{
memset(buffer,0,100);
memset(b,0,sizeof(b));
if(recv(connection, buffer,20, 0) > 0)  //pour eviter les buffer overflow
{

//ici les fonctions du serveurs si GRANTED = true !!

if(strstr(buffer,"QUIT")) {
   client.quit();
  }

/**********VERIF PASS*/
if(strstr(buffer,"PASS")) {
  if(verif < 4)    //pour eviter les attaques de brute force 
  {
    send(connection,"\nLoging, please wait...\n",sizeof("\nLoging, please wait\n"),0);
  verif++;

  
       
  if(client.veriflogin(buffer) == 1) {
                  
         
            send(connection,"\nACCESS GRANTED\n",sizeof("\nACCESS GRANTED\n"),0);
                  cout << "\nAccès autorisé au client\n";      
    }
    else
    {
            send(connection,"\nACCESS DENIED\n",sizeof("\nACCESS DENIED\n"),0);
    }
  
   }

    
   
  else {
      send(connection,"\nBrute force attack detected !!!\n",sizeof("\nBrute force attack detected !!!\n"),0);
      cout << "Brute force attack detected !!!\n";
        close(connection);
            
    }
/*************VERIF PASS*/
    
}
//pour demain, a faire: verfi brute force, buffer overflow, traitement du pass, fabrication des cmd serveurs, commentaires du prog

}
 } while(out != true);
 close(connection);
 close(s);
 return EXIT_SUCCESS;
}

void version(void) {
   system("clear");
   cout << "\n\n\tServeur paramètrable pour client Telnet 1.0\n";
  }

  
int client::registerclient(char *IP){      //pour enregistrer les infos du client dans la class
  
      IPCLIENT = IP;
      
      PORTCLIENT =  var::PORT;
      
      return 0;
  }
  
int client::veriflogin(char *PASST){     //verification du pass
  
PASSCLIENT = PASST;

if(strstr(PASSCLIENT, var::PASS)){
  GRANTED = true;
 
return 1;
}

return 0;
  }

int client::quit(void) {
  send(var::connection,"\nGood bye :)\n",sizeof("\nGood bye :)\n"),0);
          close(var::connection);
          cout << "\nDeconnection de " << IPCLIENT;
return 0;
  }