Reveiller un pc via wol wake on lan - socket en mode raw

Soyez le premier à donner votre avis sur cette source.

Vue 21 905 fois - Téléchargée 1 441 fois

Description

Voici un code permettant de réveiller un pc distant via la norme Wake On Lan (WOL).
L'exe Win32 va envoyer une trame au pc qui à besoin d'être réveillé. Cette trame contiendra la séquence magique afin que le pc distant en mode veille (WOL) comprenne qu'il doit émettre une impulsion à sa carte mère afin de s'allumer.

----------------------
http://www.frameip.com
Pour ceux qui aiment TCPIP
----------------------

Source / Exemple :


// ********************************************
// Nom du code		: WakeOnLan.cpp
// Auteur			: SebF@frameIP.com.pas.de.spam
// Date de création : 20 juillet 2003
// Version			: 1.5
// Licence			: Ce code est libre de toute utilisation.
//					  La seule condition existante est de faire référence au site www.frameip.com afin de respecter le travail d'autrui.
// ********************************************

// ********************************************************
// Reste à faire
// ********************************************************
//	2003.03.01 - Fermer proprement les socket
			
// ********************************************************
// RoadMap
// ********************************************************
//
//	Passage de la compilation en mode Release
//	Version graphique

// ********************************************************
// Suivi de projet
// ********************************************************
//
//	2003.07.30 - V1.5 - Suppression des 3 Warning
//
//	2003.07.23 - V1.4 - Ajout de mon email devant la séquence magique
//
//	2003.07.22 - V1.3 - Résolution du problème des 00, Je n'utilise plus strlen mais un compteur int que je gère moi même. Il y a avait une double erreur, l'utilisation de strlen dans memcpy et dans sendto.
//
//	2003.07.20 - V1.2 - Suppression du /NODEFAULTLIB:LIBCD.lib
//			  - Résolution du problème dans le nom de l'exe et du cpp
//			  - Envoi de la trame
//			  - Génération du code magique
//					  
//	2003.07.20 - V1.1 - Ajout de /NODEFAULTLIB:LIBCD.lib pour éviter les conflits de librairie
//			  - Suppression de la faute d'orthographe dans le nom du projet
//
//	2003.07.20 - V1.0 - Création du projet Cmd
//			  - Passage en Level 4
//			  - Suppretion du repertoire Debug
//			  - Control de la longueur
//			  - convertion des minuscule en majuscule
//			  - control que la saisie est bien une Mac adresse

// ********************************************************
// Les includes
// ********************************************************
#include <winsock2.h>
#include <cstdio>			// Pour les Sprintf
const int IP_HDRINCL=2; 	// Permet d'éviter d'intégrer #include <ws2tcpip.h> qui ne veux plus fonctionner

// ********************************************************
// Les librairies
// ********************************************************
#pragma comment(lib,"ws2_32.lib")

// ********************************************************
// Les structures des différentes entetes
// ********************************************************
struct ipv4 // htons pour les ushort et htonl pour les ulong
	{
	unsigned char		ihl:4;		// L'ordre des champs ihl et Version est inversé
	unsigned char		version:4;		// L'ordre des champs ihl et Version est inversé
	unsigned char		tos;
	unsigned short		length;
	unsigned short		id;
	unsigned short		offset:5;		// Ajout d'offset2 afin de pouvoir utiliser l'invertion qui se fait de 8 bits en 8 bits et non pas en unsigned short
	unsigned short		flag_mf:1;		// L'ordre des champs offset et flag est inversé
	unsigned short		flag_df:1;		// L'ordre des champs offset et flag est inversé
	unsigned short		flag_zero:1;	// L'ordre des champs offset et flag est inversé
	unsigned short		offset2:8;		// L'ordre des champs offset et flag est inversé
	unsigned char		ttl;
	unsigned char		type;
	unsigned short		checksum;
	unsigned long		ip_source;
	unsigned long		ip_destination;
	};

struct udp // htons pour les ushort et htonl pour les ulong
	{
	unsigned short		port_source;
	unsigned short		port_destination;
	unsigned short		length;
	unsigned short		checksum;
	};

// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void gestion_des_arguments(int argc, char* argv[]);
void envoi_de_la_trame(void);
void sortie_avec_erreur(int);
int convertion_char_int(int tampon);
void affichage_du_resultat(void);

// ********************************************************
// Les variables
// ********************************************************
char mac[100];						// Adresse MAC
struct ipv4 entete_ipv4;			// Entete IP
struct udp entete_udp;				// Entete UDP
char data_a_envoyer[65535];			// Data
int longueur_de_data_a_envoyer;		// Longueur du char *, je n'utilise pas strlen car il y a des 0
char trame_a_envoyer[65535];		// Entete IP + Entete couche 4 + data

int main (int argc, char* argv[])
	{
	initiation_des_variables();
	gestion_des_arguments(argc,argv);
	envoi_de_la_trame();
	affichage_du_resultat();
	printf("\n");
	return(1);
	}

void initiation_des_variables(void)
	{
	// ********************************************************
	// Affichage de la banniere
	// ********************************************************
	printf("\nWakeOnLan -  Wake On Lan - Version 1.5");
	printf("\nCreate on July 20, 2003, Last compilation on Febury 01, 2004");
	printf("\nSebF@FrameIP.Com - http://www.FrameIP.Com");
	printf("\n");

	// ********************************************************
	// Initiation des arguments
	// ********************************************************
	strcpy(mac,"005004A364F3");

	// ********************************************************
	// Initialisation des data
	// ********************************************************
	strcpy(data_a_envoyer,"- My Email is : SebF@FrameIP.Com -");
	longueur_de_data_a_envoyer=(int)strlen(data_a_envoyer);

	// ********************************************************
	// Initialisation de l'entête UDP
	// ********************************************************
	entete_udp.port_source=htons(3333);
	entete_udp.port_destination=htons(53);
	entete_udp.length=htons(8);
	entete_udp.checksum=0;

	// ********************************************************
	// Initialisation de l'entete Ip
	// ********************************************************
	entete_ipv4.ihl=5;
	entete_ipv4.version=4;
	entete_ipv4.tos=0;
	entete_ipv4.length=htons((unsigned short)(20+strlen(trame_a_envoyer)));
	entete_ipv4.id=(unsigned short)htonl(67);
	entete_ipv4.offset=0;
	entete_ipv4.ttl=100;
	entete_ipv4.type=17;
	entete_ipv4.ip_source=inet_addr("10.10.10.10");
	entete_ipv4.ip_destination=INADDR_BROADCAST;
	}

void gestion_des_arguments(int argc,char* argv[])
	{
	int i;

	// ********************************************************
	// Affichage de l'aide
	// ********************************************************
	if ( (argc>1) && (strcmp(argv[1],"-?")==0) || (argc==1) )
		{
		printf("\n");
		printf("\n-?         Help");
		printf("\n-mac       Mac address       Default value : %s",mac);
		printf("\n\nsample :   wakeonlan.exe     -mac 00A0C54118F8");
		printf("\n\n");
		exit(0);
		}

	// ********************************************************
	// Récupération des arguments
	// ********************************************************
	for (i=1;i<argc;i=i+1)
		if (strcmp(strlwr(argv[i]),"-mac")==0)
			strcpy(mac,argv[i+1]);
	
	// ********************************************************
	// Controle des arguments
	// ********************************************************
	if (strlen(mac)!=12)		// vérifie que la saisie est bien de 12 caractères
		sortie_avec_erreur(1);

	// Les codes 48 à 57 représentent les chiffres. 
	// Les codes 65 à 90 représentent les majuscules. 
	// Les codes 97 à 122 représentent les minuscules. 

	for (i=0;i<(int)strlen(mac);i++) 	// Boucle parcourrant les caracteres saisis
		{	
		if (int(mac[i])>=97&&int(mac[i])<=102) // Convertion des minuscules en majuscules
			mac[i]=mac[i]-32;
		if ( (int(mac[i])>=48&&int(mac[i])<=57)==FALSE ) // Si ce n'est pas un nombre
			if ( (int(mac[i])>=65&&int(mac[i])<=70)==FALSE ) // Si ce n'est pas l'une des 6 premières lettres
				sortie_avec_erreur(2);
		}
	}

void envoi_de_la_trame(void)
	{
	WSADATA initialisation_win32;
	SOCKADDR_IN information_sur_la_destination;
	int nombre_de_caractere_emis;
	SOCKET id_de_la_socket;
	int tampon;
	int i,j;
	
	// ********************************************************
	// Initialisation de la Socket
	// **************************************************
	WSAStartup(MAKEWORD(2,2),&initialisation_win32);
	id_de_la_socket=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);

	// ********************************************************
	// Activation de l'envoi de l'entete IP
	// **************************************************
	tampon=1;
	setsockopt(id_de_la_socket,IPPROTO_IP,IP_HDRINCL,(char *)&tampon,sizeof(tampon));
	setsockopt(id_de_la_socket,SOL_SOCKET,SO_BROADCAST,(char *)&tampon,sizeof(tampon));
		// SO_BROADCAST permet l'utilisation de 255.255.255.255

	// ********************************************************
	// Création de la séquence magique (6 * FF + 16 * la Mac adresse)
	// ********************************************************
	tampon=255;
	for (i=0;i<6;i++)	// Ajout des 6 FF hexa pas les lettres FF !)
		{
		memcpy(data_a_envoyer+longueur_de_data_a_envoyer,&tampon,1);
		longueur_de_data_a_envoyer++;
		}

	for (j=0;j<16;j++)	// Ajout des 16 Mac address
		for (i=0;i<12;i=i+2) // Convertit la chaine contennant la Mac adresse en hexa
			{
			tampon=convertion_char_int(mac[i])*16+convertion_char_int(mac[i+1]);
			memcpy(data_a_envoyer+longueur_de_data_a_envoyer,&tampon,1);
			longueur_de_data_a_envoyer++;
			}

	// ********************************************************
	// Préparation de la trame à envoyé
	// ********************************************************
	memcpy(trame_a_envoyer,(unsigned short *)&entete_ipv4,sizeof(struct ipv4));
	memcpy(trame_a_envoyer+sizeof(struct ipv4),(unsigned short *)&entete_udp,sizeof(struct udp));
	memcpy(trame_a_envoyer+sizeof(struct ipv4)+sizeof(struct udp),data_a_envoyer,longueur_de_data_a_envoyer);

	// ********************************************************
	// Paramètre nécessaire au sendto
	// ********************************************************
	information_sur_la_destination.sin_family=AF_INET;
	information_sur_la_destination.sin_addr.s_addr=entete_ipv4.ip_destination;

	// ********************************************************
	// Envoi de la trame
	// ********************************************************
	nombre_de_caractere_emis=sendto(id_de_la_socket,trame_a_envoyer,sizeof(struct ipv4)+sizeof(struct udp)+longueur_de_data_a_envoyer,0,(struct sockaddr*)&information_sur_la_destination,sizeof(information_sur_la_destination));
	if (nombre_de_caractere_emis<1)
		sortie_avec_erreur(3);

	// ********************************************************
	// Fermeture de la socket correspondant à la commande socket()
	// ********************************************************
	closesocket(id_de_la_socket);

	// ********************************************************
	// quite propement le winsock ouvert avec la commande WSAStartup
	// ********************************************************
	WSACleanup(); //  (A appeller autant de fois qu'il a été ouvert)
	}

void sortie_avec_erreur(int error)
	{
	if (error<3)
		printf("\nError, the Mac address format is not good\nError code : %d",error);
	if (error==3)
		printf("\nError, The magic sequence was not sent to %s address MAC\nError code : %d",mac,error);
	printf("\n\n");
	exit(0);
	}

int convertion_char_int(int caractere)
	{
	// ********************************************************
	// Convertion un caractere de type char en un nombre de type int
	// ********************************************************
	if ((caractere>=48&&caractere<=57)==TRUE)
		return(caractere-48);
	else
		return(caractere-55);
	}

void affichage_du_resultat()
	{
	// ********************************************************
	// Affichage du resultat
	// ********************************************************
	printf("\nThe magic sequence was sent to %s address MAC",mac);
	printf("\n\n");
	}

Conclusion :


----------------------
http://www.frameip.com
Pour ceux qui aiment TCPIP
----------------------

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

tibob51
Messages postés
268
Date d'inscription
vendredi 30 avril 2004
Statut
Membre
Dernière intervention
13 mai 2013
2
Salut ayant moi aussi un serveur un programme comme le tien m'intéresse.
J'ai donc exploité ton code.
J'ai aussi eu l'erreur 10004 comme nico23, après des recherche notamment sur frameip qui a l'air d'être un très bon site, j'ai pu lire que cela vien de la mise a jour d'xp (avec sp2), afin de supprimer le spoofing.
J'ai donc voulu changer la déclaration de l'en tête:

entete_ipv4.ip_source=inet_addr("127.0.0.1");//inet_addr("10.10.10.10");
entete_ipv4.ip_destination=INADDR_BROADCAST;// J'ai fait un essais avec l'ip réseau de mon serveur sans résultat

Je n'ai plus l'erreur mais malgré le message de réussite mon serveur ne démarre pas.
Si ça résous le problème pour certain merci de le dire.
noashi
Messages postés
1
Date d'inscription
lundi 12 janvier 2009
Statut
Membre
Dernière intervention
12 janvier 2009

Est ce que ce prog fonctionne sur un XP pour réveiller un linux (freenas, basé sur une distrib freeBSD) ?
Zylott
Messages postés
104
Date d'inscription
jeudi 25 juillet 2002
Statut
Membre
Dernière intervention
28 septembre 2006

Bonjour,

J'ai testé le wol et ça marche bien.
Le pc est à l'arrêt et je le fais démarrer à distance par le paquet magique. Nikel.

Mais j'ai fais un test :
je déconnecte mon dd (disque dur).
je simule un dd crashé ou hs.
je démarre le pc.
Le message boot disk failure s'affiche à l'ecran.
J'envoie le paquet magique > rien ne se passe.

Est-il possible de redemarrer le pc via un paquet magique (c'est pour voir si le dd est réellement crashé ou si le pc à planter sur un écran de démarrage avant de me déplacer sur site ) ?

merci.
Utilisateur anonyme
Bonjour à tous,
je suis novice en informatique, j'aimerai savoir comment démarrer un pc à distance via wake on lan, comment procéder? quelles applications utiliser? Surtout comment utiliser un code source tel que celui de Sebf?
merci a tous
darkanuss
Messages postés
1
Date d'inscription
vendredi 13 janvier 2006
Statut
Membre
Dernière intervention
16 janvier 2006

Slt

Super soft et explication bien précise, code bien écrit et bien commenté.

Merci ca va m'aider pour mon projet de fin d'année (2eme année ecole d'ingé).

Voila, nous voudrions faire un module connecté à un PC par la carte réseau (acceptant le WOL) de manière à le réveiller quand on est dans son lit par ex, d'un simple claquement de doigt (voir par reconnaissance vocale, ca c'est pas un probleme).

Je voulais juste savoir si tu peux me décrire exactement ce qui est envoyée (la trame) , par exemple prend l'adresse MAC de ton code source et j'analyserai. Je voudrais en fait avoir la longeur pour savoir si cette trame peut tenir dans un microcontroleur ou bien si il faut une memoire externe.

Merci beaucoup et à) bientot (jaurais surement besoin d'aide !)

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.