1. Accueil
  2. C / C++ / C++.NET
  3. Sources C / C++ / C++.NET
  4. Sources Réseaux & Internet
  5. Envoi mails avec protocole smtp

Envoi mails avec protocole smtp

5/5 (14 avis)

Vue 12 745 fois - Téléchargée 1 111 fois

Télécharger le projet
Commenter

Description

Ce code permet d'envoyer des mails en utilisant des serveurs smtp. C'est assez classique mais j'ai essayé de rajouter des options qui n'apparaissaient pas dans d'autres sources du meme genre. J'ai fait cette source car, apres avoir essayé de nombreuses sources similaires, aucune ne marchait chez moi sauf une qui n'avait pas d'interface (et dont je me suis d'ailleurs largement "inspiré" ainsi que queleques autres sources traitant du meme sujet ; chacun se reconnaitra :) )
J'ai rajouté dernièrement la possibilité d'envoyer des fichiers joints.

De plus, si vous pouviez me dire commnet il faudrait rectifier la source pour pouvoir envoyer des mails à partir d'un PC qui est connecté à internet via un réseau local...(ca ne marche pas actuellement)

N'hésitez pas à me laisser des commentaires (ca marche, ca marche pas , c nul ....) toutes les remarques sont constructives et sont donc les bienvenues.

Source / Exemple :

//////////////////////////////////////////////////////////////////
//                  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"; 
}

Conclusion :

Bon le fonctionnement est relativement simple : envoyer sert à envoyer le mail : jusque là ...
Annuler sert à déprogrammer un envoi ou à stopper l'envoi infini. Attention : annuler n'annule pas un envoi si il est déjà en cours !!!
Effacer efface sujet et corps du message.

L'option "faux envoyeur" sert à "faire croire" à qqun qu'il a recu le mail par erreur (en fait il ne verra pas son adresse ds "à:" mais l'adresse que vous aurez mis.
L'option heure réelle sert à programmer un envoi ( N'oubliez pas de mettre votre PC à l'heure)
L'option heure fausse est l'heure qui sera affichée dans le mail.(peut etre n'importe quoi par ex "salut" est une "heure" tout à fait acceptable)
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
cs_Darksheep
Messages postés
69
Date d'inscription
samedi 4 novembre 2000
Statut
Membre
Dernière intervention
15 septembre 2009
2 sept. 2007 à 11:37
oK je prend note :)
Thx for your answer
katsankat
Messages postés
571
Date d'inscription
vendredi 30 décembre 2005
Statut
Membre
Dernière intervention
12 juillet 2012
 3
31 août 2007 à 23:10
Ce n'est pas moi qui le dit mais msdn.

Pas si bête que ça d'ailleurs. Sans équivoque, c'est dit ici:
http://msdn2.microsoft.com/en-us/library/ms742213.aspx

"An application must call the WSACleanup function for every successful time the WSAStartup function is called. This means, for example, that if an application calls WSAStartup three times, it must call WSACleanup three times. The first two calls to WSACleanup do nothing except decrement an internal counter; the final WSACleanup call for the task does all necessary resource deallocation for the task."

Si on suit leur logique, il est possible qu'un prog utilise deux librairies faisant chacune appel aux sockets. Par exemple utilisant une lib pour gérer tout ce qui est UDP et l'autre pour TCP. Selon les brillantes explications de msdn si chaque lib appelle wsastartup elle doit aussi faire cleanup. CQFD. Et si en plus le prog en question fais son wsastartup, ça fait trois.

Relire ce bordel me rappelle à quel point je hais l'implémentation des socket sur win32. Elle est tout sauf conforme à la spécification établie et correctement implémentée sur plus de 20 systèmes d'exploitations sauf windoze.
cs_Darksheep
Messages postés
69
Date d'inscription
samedi 4 novembre 2000
Statut
Membre
Dernière intervention
15 septembre 2009
31 août 2007 à 20:55
Belle source :)
juste un truc katsankat :
si comme tu dit le role de WSAStartup est de vérifier la version de la dll,(Ce qui est vrai )
et qu'on doit l'appeller une seule fois au début du programme,
Alors appeller autant de fois WSACleanup() ne revient il pas à ne l'appeller qu'une fois à la fin ?
dans ce cas pourquoi spécifier qu'on doit appeller autant de fois WSACleanup que WSAStartup si on ne l'appelle qu'une fois ?C'est bête XD
KissyFroth
Messages postés
38
Date d'inscription
mardi 16 août 2005
Statut
Membre
Dernière intervention
7 avril 2007
22 avril 2006 à 16:39
Bon normalement la plupart des erreurs sont résolues, le programme ne gère pas l'envoi à plusieurs utilisateurs et je n'ai aucune idée du pourquoi, lors de certains envois, la taille des pièces jointes apparait à 0 octets. (mais bon tant que dans le contenu elles sont intactes c'est le principal non ?)
Biroto
Messages postés
11
Date d'inscription
jeudi 10 octobre 2002
Statut
Membre
Dernière intervention
15 avril 2006
15 avril 2006 à 13:46
oula dsl comme je disais jai la tete ds le cul lol
jai dit nimporte quoi
mais essayes de mettre
while( !buf[0] )
int yeah = recv( to_server_socket, buf, 1024, 0 );
buf[yeah]=0
enfin ma remarque nest surement pas tres pertinente vu que j'ai pas lu la suite du code
Afficher les 14 commentaires
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (KissyFroth)