ENVOI MAILS AVEC PROTOCOLE SMTP

//////////////////////////////////////////////////////////////////
//                  MailSender by KissyFroth                    //
//////////////////////////////////////////////////////////////////			


// Ce programme permet d'envoyer des messages via des serveurs smtp

// ATTENTION IMPORTANT : NE PAS OUBLIER D'INCLURE ws2_32.lib 
// DANS  PROJECT->SETTINGS->LINK->Objects/Library Modules





///////////////////////////////////////////
//           Serveurs SMTP               //
///////////////////////////////////////////
//        smtp.laposte.net               //
//        smtp.ifrance.com               //
//        smtp.mail.yahoo.fr             //
//      * smtp.neuf.fr                   //
//      * smtp.cegetel.net               //
//        mail.club-internet.fr          //
//        smtp.wanadoo.fr                //
//                                       //
///////////////////////////////////////////

//Les serveurs marqués de * sont testés et approuvés



/////////////////////////////////////////////////////////////////////////
// Librairies à inclure
/////////////////////////////////////////////////////////////////////////

#include <windows.h>

#include <commctrl.h>
#include "stdafx.h"
#include "resource.h"

#include <time.h>   //Librairie pour la gestion du tps

#include <winsock2.h>
#include <Ws2tcpip.h>

#include <string.h>
#include <iostream>

////////////////////////////////////////////////////
//Déclaration de variables globales
////////////////////////////////////////////////////

bool infini=false,hour_t=false,pseudo_b=false,html=false,err=false,fdest=false,hour_f=false,fj=false;


int infini1=0;
char *provisoire;  //Variable la plus importante du programme (sert à TOUT)

bool variables = false;

//Provisoires
char * mail_sender ;
char * mail_destinataire;
char * pseudo;
char * sujet_mail;
char * texte_mail;
char * type;
char * server;
char * mail_fdestinataire;
char * date;
char * fichier;
char * fichier_encode;


//Envoyées
char body [5000000];
char mail_dest[200];
char mail_send[200];

//Divers
int heure_e,minute_e; //Heure d'envoi
int nbr_mails;

int etat=0; //Etat du programme (en attente,envoi programmé,en cours d'envoi,etc...)

HWND h; //Identifiant fenetre principale

time_t temps_act; 
WSADATA wsaData;

//Variables nécéssaires à l'envoi du message


	SOCKET to_server_socket=0;
	int port=25;


//Constantes
#define BYTES_PER_LINE_BASE64   57
#define FILLCHAR_B64 			'='


/////////////////////////////////////////////////////////////////////////
//Declaration de Fonctions
/////////////////////////////////////////////////////////////////////////


bool Mef(HWND hdlg); //Vrai si tous les champs sont remplis correctement (Mise en Forme)

bool HourOK(int h,int m);    //Vrai si l'heure d'envoi est atteinte


int Envoi();      //Realise l'envoi d'un message

int GetHour();     //Recupere l'heure actuelle 
int GetMinutes();  //Devine 

void SetDate();

void info(char *text);

int nbr(char *text,int n); //Transforme les n premiers caracteres d'une chaine en un entier

void bcopy( void *source, void *destination, int size );
void bzero( void *destination, int size ) ;

bool Process( char *buffer );
int Puissance (int a,int b);


void SetDest();
void SetSender();
bool SetBody();

void Concat(char * main,char * second,int init);

void Delete();

void CloseSocket(SOCKET s);

void base64_encoding(FILE *infile, FILE *outfile);//Encodage du fichier joint


char *seek_name(char chaine[150]); //Recuperer le nom du fichier
char *verif_extens(char chaine[150]); //Verifie l'extension et retourne le type de fichier

//Callback de la fenetre
BOOL CALLBACK AppDlgProc(HWND hdlg, UINT mssg, WPARAM wParam, LPARAM lParam);




/////////////////////////////////////////////////////
//Entrée du programme
/////////////////////////////////////////////////////

int WINAPI WinMain(HINSTANCE hinst,  HINSTANCE a, PSTR b, int v)
{


	if( int err = WSAStartup( 0x0202, &wsaData ) ) 
	{
		MessageBox (NULL, TEXT ("dll winsock 2 non trouvée"), NULL, NULL);
		return 0;
	}
		
	DialogBoxParam(hinst, (LPCTSTR)PAGE, 0, AppDlgProc, 0); 

	WSACleanup();
  
	return 0;



}


//Callback de la fenetre
BOOL CALLBACK AppDlgProc(HWND hdlg, UINT mssg, WPARAM wParam, LPARAM lParam)
{

	

int wmId, wmEvent;


	switch(mssg) {
		
		case WM_INITDIALOG:
		
			h=hdlg;
			SetTimer(hdlg,NULL,1000,NULL);	
	
	SetDlgItemText(hdlg,SENDER,"anonyme@boitemail.fr");
	SetDlgItemText(hdlg,DEST,"destinataire@boitemail.fr");
	SetDlgItemText(hdlg,SERVER,"smtp.cegetel.net");
	SetDlgItemInt(hdlg,NB,1,TRUE);
			return 0;
		

		case WM_COMMAND:
		
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);

		if((LOWORD(wParam)==QUITTER)&&(HIWORD(wParam)==BN_CLICKED))
		{
			EndDialog(hdlg, 0);
			return 0;
		}
		
		else if ((LOWORD(wParam)==ANNULER)&&(HIWORD(wParam)==BN_CLICKED) && etat!=0)
		{
			etat = 0;
			Delete();
			info("Envoi Annulé");
			infini1=0;
		}
		
		else if ((LOWORD(wParam)==EFFACER)&&(HIWORD(wParam)==BN_CLICKED))
		{
			SetDlgItemText(hdlg,SUJET,"");
			SetDlgItemText(hdlg,MESSAGE,"");	
		}
		
		
		else if ((LOWORD(wParam)==ENVOYER)&&(HIWORD(wParam)==BN_CLICKED) && (etat==0))
		{
			
			if ((!hour_t) && Mef(hdlg))
			{
				if (!infini) etat = 1;
				else etat=3;
			}
			if ((hour_t) && Mef(hdlg)) etat=2;

		}
		
		
		else if ((LOWORD(wParam)==INFINI)&&(HIWORD(wParam)==BN_CLICKED))
		{
			infini= !infini;
			if (infini) EnableWindow(GetDlgItem(hdlg,NB),FALSE);
			else  EnableWindow(GetDlgItem(hdlg,NB),TRUE);
		
		}
		
		
		else if ((LOWORD(wParam)==HOUR)&&(HIWORD(wParam)==BN_CLICKED))
		{
			hour_t= !hour_t;
			if (hour_t)
			{
				EnableWindow(GetDlgItem(hdlg,HT),TRUE);
				EnableWindow(GetDlgItem(hdlg,MT),TRUE);
			}
			else  
			{
				EnableWindow(GetDlgItem(hdlg,HT),FALSE);
				EnableWindow(GetDlgItem(hdlg,MT),FALSE);
			}
		}
		
		else if ((LOWORD(wParam)==FJOO) && (HIWORD(wParam)==BN_CLICKED))
		{
			fj= !fj;
			if (fj)
			{
				EnableWindow(GetDlgItem(hdlg,FJ),TRUE);
			}
			else
			{
				EnableWindow(GetDlgItem(hdlg,FJ),FALSE);
			}
		}
		
		else if ((LOWORD(wParam)==PSEUDO1)&&(HIWORD(wParam)==BN_CLICKED))
		
		{
			pseudo_b = !pseudo_b;
			if (pseudo_b) EnableWindow(GetDlgItem(hdlg,PSEUDO),TRUE);
			else  EnableWindow(GetDlgItem(hdlg,PSEUDO),FALSE);
		}
		else if ((LOWORD(wParam)==HTML)&&(HIWORD(wParam)==BN_CLICKED))
		{
			html = !html;
		}
		
		else if ((LOWORD(wParam)==DESTF1)&&(HIWORD(wParam)==BN_CLICKED))
		{
			
			fdest= !fdest;
			if (fdest) EnableWindow(GetDlgItem(hdlg,DESTF),TRUE);
			else  EnableWindow(GetDlgItem(hdlg,DESTF),FALSE);
		
		}
		else if ((LOWORD(wParam)==HOURF)&&(HIWORD(wParam)==BN_CLICKED))
		{
			
			hour_f= !hour_f;
			if (hour_f)
			{ 
				EnableWindow(GetDlgItem(hdlg,HF),TRUE);
			}
			else
			{
				EnableWindow(GetDlgItem(hdlg,HF),FALSE);
			}
		}
		
		return 0;

		case WM_TIMER:

			if (etat != 0) EnableWindow(GetDlgItem(h,ENVOYER),FALSE);	
			else EnableWindow(GetDlgItem(h,ENVOYER),TRUE);

			if (etat == 1)
			{
				if (nbr_mails>0)
				{
					etat=4;
					if (Envoi()==1) info("Message envoyé avec succès") ;
					else info("L'envoi du message a échoué"); 
					nbr_mails--;
					etat=1;
				}
				else
				{
					etat=0;
					Delete();
				}
			}

			if (etat == 2)
			{
				if (infini1 == 0 && infini )
				{ 
					provisoire = new char [200];
					Concat(provisoire,"Envois mis en attente (infini)",1);
					info(provisoire);
					infini1=1;
					delete provisoire;
				}
				if (infini1 == 0 && !infini )
				{ 
					char * temp1;
					temp1= new char [10];
					provisoire = new char [200];
					Concat(provisoire,"Envois mis en attente ",1);
					Concat(provisoire,itoa(nbr_mails,temp1,10),0);
					info(provisoire);
					infini1=2;
					delete temp1;delete provisoire;
				}
				
				if (HourOK(heure_e,minute_e)) 
				{
					if (infini1 == 1){
						infini1=0;
						etat = 3;
					}
					else
					{
						infini1=0;
						etat=1;
					}
				}
			}
			
			if (etat == 3)
			{
				etat=4;
				if (Envoi()==1) info("Message envoyé avec succès") ;
				else info("L'envoi du message a échoué"); 
				etat=3;
			}


		return 0;

		case WM_CLOSE:
			
			EndDialog(hdlg, 0);
		return 0;

	}

  return 0;
}





/////////////////////////////////////////
// Implémentation des Fonctions 
/////////////////////////////////////////



//Fonction qui détermine si l'heure d'envoi est atteinte
	bool HourOK(int h,int m){


	 // Déterminer le temps actuel en secondes 

	int heures = GetHour();
	int minutes = GetMinutes();

		return ((h==heures) && (m==minutes));
		
	}


//Fonction GetHour (recupere l'heure actuelle)
	int GetHour(){
		
		char result[3];
		time(&temps_act);
		char * date = ctime(&temps_act);

		result[0]=date[11];
		result[1]=date[12];
		result[2]='\0';
	
		return nbr(result,2);
	}

//Fonction GetMinutes
	int GetMinutes(){
		
		char result[3];
		time(&temps_act);
		char * date = ctime(&temps_act);
		
		result[0]=date[14];
		result[1]=date[15];
		result[2]='\0';
	
		return nbr(result,2);

	}


//Transformation des n premiers caracteres d'une chaine en un nombre
int nbr(char * text,int n){
		
	int a=strlen(text),b=0,c=0,d=0;
	
	if (a>n) a=n;
	else n=a;     //les 2 valeurs doivent avoir la valeur min pour la suite

	char chiffres[11] = "0123456789";
		
	while(a>0) 
	{
		for(int i=0;i<10;i++) {
			if ((text[n-a])==(chiffres[i])) {
				c=i; 
				break;
			}
		}

		c*=Puissance(10,(a-1));
			
		d+=c;
		c=0;
		a--;
	}
	
	return d;	
}

//Fonction Puissance (retourne a^b)
int Puissance (int a,int b)
{

	if (b==0) return 1;
	while (b>1){
		a*=a;
		b--;
	}
	return a;
}

//Fonction bcopy
void bcopy( void * source, void * destination, int size ) 
{ 
   char * src = ( char * ) source; 
   char * dst = ( char * ) destination; 
  
   for( int i=0; i<size; i++ ) 
      dst[i] = src[i]; 
} 
  

//Fonction bzero 
void bzero( void * destination, int size ) 
{ 
   char * dst = ( char * ) destination; 
  
   for( int i=0; i<size; i++ ) 
      dst[i] = 0x00; 
} 



void info(char * text)
{
	SetDlgItemText(h,INFO,text);
}


/////////////////////////////////////////////////////////////////////////
//Fonction d'envoi du message	
/////////////////////////////////////////////////////////////////////////

int Envoi(){




		int not = 0; 
	    unsigned long ioctl_blocking = 1; 
		
   struct sockaddr_in serverSockAddr; // addresse de la socket 
   struct hostent * serverHostEnt; // description du host serveur 
   long hostAddr; // addr du serveur 
  


   bzero( &serverSockAddr, sizeof( serverSockAddr ) ); // initialise a zero serverSockAddr 
   // converti l'adresse ip 9.100.1.1 en entier long 
   hostAddr = inet_addr( server );   //SERVER
  
   if( ( long ) hostAddr != ( long ) -1 ) 
      bcopy( &hostAddr, &serverSockAddr.sin_addr, sizeof( hostAddr ) ); 
   else // si on a donne un nom 
   { 
      
	   
	 
	  
	   serverHostEnt = gethostbyname( server );  //SERVER
      if ( serverHostEnt == NULL ) 
      { 
         MessageBox (NULL, TEXT ("Erreur dans la résolution de l'host du \n server SMTP. Vérifiez le nom du server."), 
         NULL, NULL);
		 return 0;
	  } 
      bcopy( serverHostEnt->h_addr, &serverSockAddr.sin_addr, serverHostEnt->h_length ); 
   } 

   serverSockAddr.sin_port = htons( port ); // host to network port 
   serverSockAddr.sin_family = AF_INET; // AF_*** : INET=internet 
   // creation de la socket 
  
   to_server_socket = socket( AF_INET, SOCK_STREAM, 0 ); 
   if ( to_server_socket < 0) 
   { 
      MessageBox (NULL, TEXT ("Erreur dans la création de la socket.Vérifiez votre connection internet."), 
            NULL, NULL);
			return 0;
   } 
  
   setsockopt(to_server_socket, SOL_SOCKET, SO_DONTLINGER, (char *) &not, sizeof(not)); 
  
  
   // requete de connexion 
   if( connect( to_server_socket, ( struct sockaddr * ) &serverSockAddr, 
                                      sizeof( serverSockAddr ) ) < 0 ) 
   { 
      MessageBox (NULL, TEXT ("Erreur dans la connection de la socket."), 
            NULL, NULL);
			return 0;
   } 
  
   ioctlsocket ( to_server_socket, FIONBIO, &ioctl_blocking ); 
  
   char buf[ 1024 ]; 
   buf[0] = 0x00; 
   while( !buf[0] ) 
      int yeah = recv( to_server_socket, buf, 1024, 0 ); 


	if (!Process( "EHLO Lalala\r\n"))  
	{
	   CloseSocket(to_server_socket); 
		return 0;
    }
	if (!Process( mail_send  ))
	{        
		CloseSocket(to_server_socket); 
		return 0;
	}
		
	if (!Process( mail_dest  ))
	{
		CloseSocket(to_server_socket); 
		return 0;
	}
	if (!Process( "DATA\r\n" ))
	{
        CloseSocket(to_server_socket); 
		return 0;
	}
	if (!Process( body       ))
	{
		CloseSocket(to_server_socket);
		return 0;
	}
	if (!Process( "QUIT\r\n" ))
	{
        CloseSocket(to_server_socket);
		return 0;
	}

   /* fermeture de la connection */ 
	CloseSocket(to_server_socket);
   
return 1;

}

//Fonction Process (un jour vous me remercierez pour mes commentaires si utiles)
bool Process( char * buffer )
{


   char buf[ 1024 ];
	buf[0] = 0x00;
   
	int size = strlen( buffer );
   int retVal = send( to_server_socket, buffer, size, 0 );

   while( !buf[0] )
      int yeah = recv( to_server_socket, buf, 1024, 0 ); 
	
    int a=nbr(buf,3);
	
	if (a!=250 && a!=354 && a!=221) {
		return false;
	}
return true;

//char temp[50];
	
//itoa(nbr(buf,3),temp,10);
//info(temp);


}

///////////////////////////////////////////////////////
//Fonction de mise en forme du message
///////////////////////////////////////////////////////

bool Mef(HWND hdlg){


	err=false;

	variables = true;

//Adresse mail imaginaire de l'envoyeur


	provisoire = new char [200];
	GetDlgItemText(hdlg,SENDER,provisoire,198);
	mail_sender = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
	{
	
		Concat(mail_sender,provisoire,1);
	//Ne jamais mettre un char * en premier param d'une fonction strcpy
	}

	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir l'adresse mail imaginaire"), 
    NULL, NULL);
	}		
	delete provisoire;


//Adresse mail du destinataire

	provisoire = new char [200];
	GetDlgItemText(hdlg,DEST,provisoire,200);
	mail_destinataire = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
		Concat(mail_destinataire,provisoire,1);

	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir l'adresse du destinataire"), 
    NULL, NULL);
	}
	delete provisoire;

//Adresse mail du faux destinataire

if (fdest)
{
	
	provisoire = new char [200];
	GetDlgItemText(hdlg,DESTF,provisoire,200);
	mail_fdestinataire = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
		
		Concat(mail_fdestinataire,provisoire,1);

	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir l'adresse du destinataire"), 
    NULL, NULL);
	}
	delete provisoire;
}
else mail_fdestinataire = new char [2];


//Pseudo
if (pseudo_b)
{
	provisoire = new char [200];
	GetDlgItemText(hdlg,PSEUDO,provisoire,200);
	pseudo = new char [strlen(provisoire)+2];
	
	Concat(pseudo,provisoire,1);
	
	delete provisoire;
				
}
else pseudo = new char [2];


//Serveur

	provisoire = new char [200];
	GetDlgItemText(hdlg,SERVER,provisoire,200);
	server = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
	{
		Concat(server,provisoire,1);	
	}
	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir le serveur smtp"), 
    NULL, NULL);
	}
	delete provisoire;
	
//Sujet

	provisoire = new char [200];
	GetDlgItemText(hdlg,SUJET,provisoire,200);
	sujet_mail = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
		Concat(sujet_mail,provisoire,1);

	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir le sujet"), 
    NULL, NULL);
	}
	delete provisoire;

//Corps du message

	provisoire = new char [1000];
	GetDlgItemText(hdlg,MESSAGE,provisoire,1000);
	texte_mail = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
		Concat(texte_mail,provisoire,1);

	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir le corps du message"), 
    NULL, NULL);
	}
	delete provisoire;
					

//Fichier joint

if (fj)
{
	
	provisoire = new char [200];
	GetDlgItemText(hdlg,FJ,provisoire,200);
	fichier = new char [strlen(provisoire)+2];
	if(strlen(provisoire)>0)
		
		Concat(fichier,provisoire,1);

	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir le fichier joint"), 
    NULL, NULL);
	}
	delete provisoire;
}
else fichier = new char [2];
	


//Nombre de messages

	provisoire = new char [200];
	GetDlgItemText(hdlg,NB,provisoire,200);
	if(strlen(provisoire)>0)
		
		nbr_mails=(atoi(provisoire));  //int
	
	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir le nombre de messages"), 
    NULL, NULL);
	}
	delete provisoire;
	
if (hour_t)
{	

//Heures reelles

	provisoire = new char [200];
	GetDlgItemText(hdlg,HT,provisoire,200);
	if(strlen(provisoire)>0)
	{
		
		heure_e=atoi(provisoire); //int
		if (heure_e > 23) 
		{
			MessageBox (NULL, TEXT ("Erreur : Les heures ne sont pas valides"), 
			NULL, NULL);
			err=true;
		}
	}
	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir l'heure reelle"), 
    NULL, NULL);
	}
	delete provisoire;

//Minutes reelles

	provisoire = new char [200];
	GetDlgItemText(hdlg,MT,provisoire,200);
	if(strlen(provisoire)>0)
	{
		
		minute_e=atoi(provisoire); //int
		if (minute_e > 59) 
		{
			MessageBox (NULL, TEXT ("Erreur : Les minutes ne sont pas valides"), 
			NULL, NULL);
			err=true;
		}
	}
	else
	{	
	err=true;
	MessageBox (NULL, TEXT ("Erreur : Vous devez remplir les minutes reelle"), 
    NULL, NULL);
	}
	delete provisoire;	
}	
	
//Fausse Heure et Format Date

if (hour_f)
{
	
	provisoire = new char [200];
	GetDlgItemText(hdlg,HF,provisoire,200);
	date = new char [strlen(provisoire)+2];
	
		Concat(date,provisoire,1);
	
	delete provisoire;
}
else 
{
	date = new char [33];

	time(&temps_act);
	char * date1 = ctime(&temps_act);

//Au niveau de l'esthetique de prog,c'est horrible mais j'ai la flemme...
//Cette partie sert à enlever le "CET" que l'on voit dans la date 
//(ca peut etre utile : si vous voulez absolument le rajouter servez vous 
//de l'option "fausse date")

	date[0]=date1[0];date[1]=date1[1];date[2]=date1[2];date[3]=',';     date[4]=date1[3];
	date[5]=date1[8];date[6]=date1[9];date[7]=date1[3];date[8]=date1[4];date[9]=date1[5];
	date[10]=date1[6];date[11]=date1[3];date[12]=date1[20];date[13]=date1[21];
	date[14]=date1[22];date[15]=date1[23];date[16]=date1[3];date[17]=date1[11];
	date[18]=date1[12];date[19]=date1[13];date[20]=date1[14];date[21]=date1[15];
	date[22]=date1[16];date[23]=date1[17];date[24]=date1[18];date[25]=date1[3];
	date[26]='+';date[27]='0';date[28]='1';date[29]='0';date[30]='0';date[30]='0';
	date[31]='\0';

//Fri, 06 Jan 2006 16:46:38 +0100       //Heure Mail
//0123456789012345678901234567890
//Sun Jan 08 16:29:39 2006              //Heure PC
	

}


	SetDest();
	SetSender();
	if (!SetBody()) 
	{
		err=true;
	}
	
	if (err) 
	{
		info("Envoi échoué");
		Delete();
	}
	
	return !err;

}



//Fonction GetDest
void SetDest()
{	
	Concat(mail_dest,"RCPT To: <",1);
	Concat(mail_dest,mail_destinataire,0);
	Concat(mail_dest,">\r\n",0);
}
	
	
void SetSender()
{
		Concat(mail_send,"MAIL From: <",1);
		Concat(mail_send,mail_sender,0);
		Concat(mail_send,">\r\n",0);
}
	
	
	
bool SetBody()
{
	Concat(body,"From: ",1);	
	
	if (pseudo_b)Concat(body,pseudo,0);
	
	Concat(body,"<",0);
	Concat(body,mail_sender,0);
	Concat(body,">",0);

		
	Concat(body,"\r\nSubject: ",0);
	Concat(body,sujet_mail,0);

	Concat(body,"\r\nTo: ",0);

	if (fdest) Concat(body,mail_fdestinataire,0);
	else Concat(body,mail_destinataire,0);
	

	Concat(body,"\r\nDate: ",0);
	Concat(body,date,0);


	char *Type;
	if (html)
	{
		//Concat(body,"\r\n",0);
		//Concat(body,"Content-Type: text/html; charset=iso-8859-1\n",0);
		Type = "html";
	}
	else Type = "plain";

//	if(fj)
//	{
		Concat(body,"\r\nMIME-Version: 1.0",0);
		Concat(body,"\r\nContent-Type: multipart/mixed;",0);
		Concat(body," boundary=\"Boundary_(ID_JK8sfTufWdySQFXNsMQU4Q)\"\r\n\r\n",0);
	
		Concat(body,"--Boundary_(ID_JK8sfTufWdySQFXNsMQU4Q)\r\n",0);
		Concat(body,"Content-Type: text/",0);
		Concat(body,Type,0);
		Concat(body,"; charset=iso-8859-1",0);
		
//	}

//*/
	Concat(body,"\r\n\r\n",0);
	Concat(body,texte_mail,0);



	if (fj)
	{

	Concat(body,"\r\n",0);

	Concat(body,"--Boundary_(ID_JK8sfTufWdySQFXNsMQU4Q)\r\n",0);
	Concat(body,"Content-Type: ",0);
	Concat(body,verif_extens(fichier),0);
	Concat(body,";",0);
	Concat(body," name=\"",0);
	Concat(body,seek_name(fichier),0);
	Concat(body,"\"\r\n",0);
	Concat(body,"Content-Transfer-Encoding: base64\r\n",0);
	Concat(body,"Content-Disposition: attachment;",0);
	Concat(body," filename=\"",0);
	Concat(body,seek_name(fichier),0);
	Concat(body,"\"\r\n\r\n",0);


		FILE *infile=fopen(fichier,"rb");
		if(!infile) 	return false;
		
		FILE *outfile=fopen("$$$$$$$$.$$$","w");
			if(infile) 	
			{
				base64_encoding(infile, outfile);
				fclose(infile);
				fclose(outfile);
				infile=fopen("$$$$$$$$.$$$","r");
				char *buf_lecture=new char[1024+1];
				while(!feof(infile))
				{
				fread(buf_lecture,1024,1,infile);
				Concat(body,buf_lecture,0);
				}
				fclose(infile);
				delete buf_lecture;
				remove("$$$$$$$$.$$$");
			}
				
	}//IF (fj) 


	Concat(body,"\r\n.\r\n",0);
//*/

	return true;

}



//Fonction Concat
void Concat(char * main,char * second,int init){

		if (init==0)
		{
			main+=strlen(main);
			strcpy(main,second);
		}
		else strcpy(main,second);
			
}


void Delete()
{
	
	if (variables)
	{

	delete mail_sender;
	delete mail_destinataire;
	delete mail_fdestinataire;
	delete pseudo;
	delete sujet_mail;
	delete texte_mail;
	delete type;
	delete server;
	delete date;
	delete fichier;
	}

	variables = false;
}

//Fermeture d'une socket
void CloseSocket(SOCKET s)
{
	shutdown(s,2); 
	closesocket( s );
}


//Fonction d'encodage d'un fichier en base 64
void base64_encoding(FILE *infile, FILE *outfile)
{
	u_long lines_per_part=10;
	char B64_code[64];

	//init base64 encoding:
	int i;
	for(i=0;i<26;i++) 	B64_code[i]=(i+'A');
	for(i=26;i<52;i++)	B64_code[i]=(i+'G');
	for(i=52;i<62;i++)	B64_code[i]=(i-4);
	B64_code[62]='+';
	B64_code[63]='/';

	size_t read_chars=32718;
	char in_line[32718];
	size_t bytes_read=0;
	int lines_per_round;
	char *source=in_line;
	char out_line[45900];
	char *dest=&out_line[0];
	int count, rounds;

	lines_per_round=read_chars/BYTES_PER_LINE_BASE64;
	rounds=BYTES_PER_LINE_BASE64/3;

	while(!feof(infile) && lines_per_round>0)
	{
		if(lines_per_round>lines_per_part)
		{		  read_chars=lines_per_part*BYTES_PER_LINE_BASE64;
				  lines_per_part=lines_per_round;	}
		bytes_read=fread(in_line,1,read_chars,infile);
		source=&in_line[0];
		i=bytes_read/BYTES_PER_LINE_BASE64;
		bytes_read-=i*BYTES_PER_LINE_BASE64;
		while(i-->0)
		{
			count=rounds;
			while(count-->0)
			{
				*dest++=B64_code[(*source & 252)>>2];
				*dest++=B64_code[((*source & 3)<<4) | ((*(source+1) & 240)>>4)];
				*dest++=B64_code[((*(source+1) & 15)<<2) | ((*(source+2) & 192)>>6)];
				*dest++=B64_code[*(source+2) & 63];
				source+=3;
			}
		}
		fwrite(&out_line[0],dest - &out_line[0],1,outfile);
		dest=&out_line[0];
		lines_per_part=lines_per_round;
	}
	if(bytes_read>0)
	{
		while(bytes_read>=3)
		{
			*dest++=B64_code[(*source & 252)>>2];
			*dest++=B64_code[((*source & 3)<<4) | ((*(source+1) & 240)>>4)];
			*dest++=B64_code[((*(source+1) & 15)<<2) | ((*(source+2) & 192)>>6)];
			*dest++=B64_code[*(source+2) & 63];
			source+=3;bytes_read-=3;
		}
		if(bytes_read==2)
		{
			*dest++=B64_code[(*source & 252)>>2];
			*dest++=B64_code[((*source & 3)<<4) | ((*(source+1) & 240)>>4)];
			*dest++=B64_code[(*(source+1) & 15)<<2];
			*dest++=FILLCHAR_B64;
		}
		if(bytes_read==1)
		{
			*dest++=B64_code[(*source & 252)>>2];
			*dest++=B64_code[(*source & 3)<<4];
			*dest++=FILLCHAR_B64;
			*dest++=FILLCHAR_B64;
		}
	}
	if(dest!=&out_line[0])
		fwrite(&out_line[0],dest - &out_line[0],1,outfile);
}



//Fonction pour récupérer le nom du fichier
char *seek_name(char chaine[150])
{
	int len=strlen(chaine), debut=1;
	for(int a=len;a>=1;a--)
		if( (debut==1) && (chaine[a]=='\\') )
			debut=a+1;
	char *nom_fichier=new char[len-debut+3];
	for(int z=debut,b=0;z<=len;z++, b++)
		nom_fichier[b]=chaine[z];
	return nom_fichier;
}

//Fonction qui examine l'extension et qui retourne le type de fichier en conséquence

char *verif_extens(char chaine[150])
{
	int len=strlen(chaine);
	char *type_fichier;
	
	for(int a=len;a>=0;a--)
	{
		if(chaine[a]=='.')
		{
			if( (chaine[a+1]=='e') && (chaine[a+2]=='x') && (chaine[a+3]=='e') )
			{	//application exe :
				type_fichier="application/octet-stream";
				return type_fichier; }
			if( (chaine[a+1]=='g') && (chaine[a+2]=='i') && (chaine[a+3]=='f') )
			{	//image gif :
				type_fichier="image/gif";
				return type_fichier; }
			if( (chaine[a+1]=='j') && (chaine[a+2]=='p') && (chaine[a+3]=='g') )
			{	//image jpeg :
				type_fichier="image/jpeg";
				return type_fichier; }
			if( (chaine[a+1]=='m') && (chaine[a+2]=='p') && (chaine[a+3]=='g') )
			{	//vidéo mpeg :
				type_fichier="video/mpeg";
				return type_fichier; }
			if( (chaine[a+1]=='p') && (chaine[a+2]=='c') && (chaine[a+3]=='m') )
			{	//son pcm :
				type_fichier="audio/basic";
				return type_fichier; }
			if( (chaine[a+1]=='b') && (chaine[a+2]=='m') && (chaine[a+3]=='p') )
			{	//son pcm :
				type_fichier="image/bmp";
				return type_fichier; }
			if( (chaine[a+1]=='t') && (chaine[a+2]=='x') && (chaine[a+3]=='t') )
			{	//son pcm :
				type_fichier="texte/txt";
				return type_fichier; }

		}

	}
	return "type_inconnu"; 
}