Vu que la met à NULL, je met 0, 0, c'est ca ?

-
Edité par raphaeldesaintalbin 26 septembre 2017 à 9:57:57

Une liste avec 0 élément maximum ?

Je ne sais pas où vous vous servez de cette structure, mais ça me parait étrange.

Je ne sais pas, comment trouver cette valeur ? et le nombre de champs remplis est égal à zéro car je met NULL pour cette structure...

voici l'endroit dans mon code ou il doit y avoir une erreur...

	_DOT11_SSID structSSID;
	std::string strSSID(recupSSID());
	int taille(strSSID.size());
	structSSID.uSSIDLength = taille;
	memcpy(structSSID.ucSSID, strSSID.c_str(), taille);
	_NDIS_OBJECT_HEADER ndis{ NDIS_OBJECT_TYPE_DEFAULT, DOT11_BSSID_LIST_REVISION_1, sizeof(DOT11_BSSID_LIST) };
	DOT11_BSSID_LIST bssid{ ndis, /*?*/0, /*?*/0, NULL };

Merci d'avance

-
Edité par raphaeldesaintalbin 26 septembre 2017 à 18:57:29

Votre manière d'initialiser des structures C avec des "list initialisation" me fait toujours aussi peur.

Je suis a peu près sûr que le résultat de cette manière d'initialiser des structures C pose ou va poser des problèmes.

Comme je l'ai déjà indiqué, implicitement dans l'API Win32, tout champ ou parti d'un champ de la structure qui n'est pas "utilisé" doit être initialisé à '0'.

Pour les lignes 1 à 5, vous avez peut-être copié la chaine de caractère "strSSID", mais, à moins d'avoir la chance que la longueur de la chaine de caractère "strSSID" soit pile-poil égal à DOT11_SSID_MAX_LENGTH, vous n'êtes pas dans les clous.

Les caractères entre la taille de "strSSID" et DOT11_SSID_MAX_LENGTH doivent être à '0', d'où l'intérêt de l'utilisation systématique de ZeroMemory avant tout "remplissage".

>Je ne sais pas, comment trouver cette valeur ?

Là, je pense qu'on a un très gros problème. C'est votre code qui fait les allocations de mémoires, c'est donc vous qui êtes le seul à pouvoir correctement remplir ces champs.

"DOT11_MAC_ADDRESS" n'est pas un pointeur, c'est un tableau, qui prend, par défaut, la taille d'une adresse MAC.

Il y a donc, pour moi, une incohérence entre la valeur de "Header.Size" et des champs "uNumOfEntries" et "uTotalNumOfEntries" car l'un, indique implicitement une adresse MAC ("Header.Size") et les autres 0.

Un champ non utilisé, c'est rempli avec ZeroMemory, pas avec "NULL" (Ok, ça devrait pas changer grand chose, mais au moins on voit ce que l'on cherche à faire).

La documentation sur DOT11_BSSID_LIST est peut-être un peu piégeuse mais généralement, ce type de liste n'est pas vide.

Win32 ne fait généralement pas d'allocation, c'est à vous d'allouer le nombre d'octets nécessaire pour que Win32 remplisse ce tableau.

Quelle primitive Win32 se prend cette structure dans les dents ?

bacelar a écrit:

Votre manière d'initialiser des structures C avec des "list initialisation" me fait toujours aussi peur.

Je suis a peu près sûr que le résultat de cette manière d'initialiser des structures C pose ou va poser des problèmes.

Comme je l'ai déjà indiqué, implicitement dans l'API Win32, tout champ ou parti d'un champ de la structure qui n'est pas "utilisé" doit être initialisé à '0'.

Donc je dois initialiser la structure avec uniquement des zeros puis la remplir ? ou faire un peu comme ca :

	_DOT11_SSID structSSID;
	std::string strSSID(recupSSID());
	int taille(strSSID.size());
	memset(&structSSID, 0, sizeof(_DOT11_SSID));
	memcpy(structSSID.ucSSID, strSSID.c_str(), taille);
	structSSID.uSSIDLength = taille;
	_NDIS_OBJECT_HEADER ndis;
	memset(&ndis, 0, sizeof(_NDIS_OBJECT_HEADER));
	ndis.Type = NDIS_OBJECT_TYPE_DEFAULT;
	ndis.Revision = DOT11_BSSID_LIST_REVISION_1;
	ndis.Size = sizeof(DOT11_BSSID_LIST);
	DOT11_BSSID_LIST bssid;
	memset(&bssid, 0, sizeof(DOT11_BSSID_LIST));
	bssid.Header = ndis;
	bssid.uNumOfEntries = /*?*/0;
	bssid.uTotalNumOfEntries = /*?*/0;

bacelar a écrit:

Pour les lignes 1 à 5, vous avez peut-être copié la chaine de caractère "strSSID", mais, à moins d'avoir la chance que la longueur de la chaine de caractère "strSSID" soit pile-poil égal à DOT11_SSID_MAX_LENGTH, vous n'êtes pas dans les clous.

Les caractères entre la taille de "strSSID" et DOT11_SSID_MAX_LENGTH doivent être à '0', d'où l'intérêt de l'utilisation systématique de ZeroMemory avant tout "remplissage".

donc faire ce que je dis au dessus devrait régler ce problème...

bacelar a écrit:

>Je ne sais pas, comment trouver cette valeur ?

Là, je pense qu'on a un très gros problème. C'est votre code qui fait les allocations de mémoires, c'est donc vous qui êtes le seul à pouvoir correctement remplir ces champs.

"DOT11_MAC_ADDRESS" n'est pas un pointeur, c'est un tableau, qui prend, par défaut, la taille d'une adresse MAC.

Il y a donc, pour moi, une incohérence entre la valeur de "Header.Size" et des champs "uNumOfEntries" et "uTotalNumOfEntries" car l'un, indique implicitement une adresse MAC ("Header.Size") et les autres 0.

oui mais étant donné que je ne remplis pas ce champ, la taille de la liste est 0 non ?

-
Edité par raphaeldesaintalbin 26 septembre 2017 à 21:30:46

>Donc je dois initialiser la structure avec uniquement des zeros puis la remplir ? ou faire un peu comme ca :

Heu, c'est un peu ce que vous faites, non ???

J'utiliserais ZeroMemory à la place du memset pour que cela soit plus "lisible".

Quand on fait beaucoup de code Win32, notre cerveau "zape" les ZeroMemory parce qu'on sait que c'est juste de l'initialisation, memset, ça peut être pour autre chose, donc moins lisible.

>donc faire ce que je dis au dessus devrait régler ce problème...

Oui.

>oui mais étant donné que je ne remplis pas ce champ, la taille de la liste est 0 non ?

Le taille de la liste initialisé oui, c'est 0, donc "uNumOfEntries" c'est 0, mais vous avez "alloué" sur la pile de quoi mettre une adresse MAC (c'est le petit "[1]" dans la définition de la structure), donc "uTotalNumOfEntries" doit être égal à 1.

Il faut bien voir que généralement, dans ce type de code, on n'alloue des buffers d'octets "à la main" et on les remplit consciencieusement.

Alors j'ai réglé tout ca, voici la dernière version de ma fonction connexionWifi :

DWORD connexionWifi(std::string choixCoo)
{
	HANDLE handle(recupHandle());
	std::string GUIDString(recupGUID());
	std::wstring GUIDWstring = s2ws(GUIDString);
	LPCWSTR GUIDStringUni(GUIDWstring.c_str());
	GUID GUID;
	IIDFromString(GUIDStringUni, &GUID);
	LPCWSTR profilXML(creerProfil(choixCoo));

	_DOT11_SSID structSSID;
	std::string strSSID(recupSSID());
	int taille(strSSID.size());
	ZeroMemory(&structSSID, sizeof(_DOT11_SSID));
	memcpy(structSSID.ucSSID, strSSID.c_str(), taille);
	structSSID.uSSIDLength = taille;
	_NDIS_OBJECT_HEADER ndis;
	ZeroMemory(&ndis, sizeof(_NDIS_OBJECT_HEADER));
	ndis.Type = NDIS_OBJECT_TYPE_DEFAULT;
	ndis.Revision = DOT11_BSSID_LIST_REVISION_1;
	ndis.Size = sizeof(DOT11_BSSID_LIST);
	DOT11_BSSID_LIST bssid;
	ZeroMemory(&bssid, sizeof(DOT11_BSSID_LIST));
	bssid.Header = ndis;
	bssid.uNumOfEntries = 0;
	bssid.uTotalNumOfEntries = 1;

	WLAN_CONNECTION_PARAMETERS connect;
	ZeroMemory(&connect, sizeof(WLAN_CONNECTION_PARAMETERS));
	connect.wlanConnectionMode = wlan_connection_mode_profile;
	connect.strProfile = profilXML;
	connect.dwFlags = WLAN_CONNECTION_IGNORE_PRIVACY_BIT;
	connect.pDot11Ssid = &structSSID;
	connect.pDesiredBssidList = &bssid;
	connect.dot11BssType = dot11_BSS_type_infrastructure;
	DWORD error;
	HANDLE handle2(recupHandle());
	DWORD dwReason;
	if ((error = WlanRegisterNotification(handle2, WLAN_NOTIFICATION_SOURCE_ALL, true, (WLAN_NOTIFICATION_CALLBACK)WlanNotification, &WlanNotification, 0, &dwReason)) != ERROR_SUCCESS)
	{
		std::cout << "WlanRegisterNotification a echoue\n" << std::endl;
		switch (error)
		{
		case ERROR_INVALID_HANDLE:
			std::cout << "handle invalide" << std::endl;
			break;
		case ERROR_NOT_ENOUGH_MEMORY:
			std::cout << "pb memoire" << std::endl;
			break;
		case ERROR_INVALID_PARAMETER:
			std::cout << "parametre invalide" << std::endl;
			break;
		}
	}
	if ((error = WlanConnect(handle, &GUID, &connect, NULL)) != ERROR_SUCCESS)
	{
		std::cout << "La demande de connexion a echoue\n" << std::endl;
		switch (error)
		{
		case ERROR_INVALID_HANDLE:
			std::cout << "Handle invalide" << std::endl;
			break;
		case ERROR_ACCESS_DENIED:
			std::cout << "Acces refusé" << std::endl;
			break;
		case ERROR_INVALID_PARAMETER:
			std::cout << "Parametre invalide" << std::endl;
			throw "parametre invalide";
			break;
		}
	}
	else
	{
		std::cout << "La demande de connexion reussi\n" << std::endl;
	}
	return error;
}

Je commence à re-regarder tous les paramètres que j'envoie aux fonctions, si vous voyez quelque de suspect, dites le moi svp...

Pensez vous que ce soit possible que ca ne marche pas car je ne renseigne pas l'adresse mac ?

merci pour votre investissement,

Raphaël

-
Edité par raphaeldesaintalbin 27 septembre 2017 à 13:26:04

Juste pour dire que je suis toujours le sujet, mais que je n'ai rien de plus intéressant à dire que bacelar qui a plus de patience/connaissance que moi pour expliquer.

Pour ton code, j'essaierai de bien vérifier les chaines de caractères que tu passes à ta fonction: sont elles bien dans le bon format(unicode), de la bonne longueur? (faut il le zero terminal?) ...

Ce lien semble proposer un code (en C) bien élaborer: http://gaiger-programming.blogspot.fr/2015/03/connect-to-specified-wifi-router-by.html

> Pensez vous que ce soit possible que ca ne marche pas car je ne renseigne pas l'adresse mac ?

Je ne vois nulle-part la mention que si l'adresse MAC n'est pas fournie, l'API se démerderait, donc non, ne fait pas cette assertion.

Vous pouvez toujours faire des tests avec des valeurs en dur, pour commencer.

Il y a déjà pas mal de trucs plateforme dépendant signalée dans la documentation :

https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms706613(v=vs.85).aspx

Je ne vois rien dans votre code pour gérer tout ce merdier.

La documentation donne déjà une liste longue comme le bras de problèmes potentiels.

Vous devriez commencez par vérifier un par un ces cas.

Commencez par faire fonctionner un POC avec un appel avec des valeurs en dur, puis avec 2 appels en dur, etc...

Une fois que vous avez un truc avec les valeurs en dur qui fonctionne, modifiez votre code pour des valeurs dynamiques, mais en faisant le changement appel par appel et en testant avant de faire la modification de l'appel suivant, etc...

Il a quoi comment comportement votre code actuel ? (celui que vous nous avez posté)

@breizhbugs,
j'ai lu le code de votre lien et j'ai voulu le compiler mais ca ne marche pas :

@bacelar

alors j'ai pas tout compris, notamment ca :

"Vous pouvez toujours faire des tests avec des valeurs en dur, pour commencer.

Il y a déjà pas mal de trucs plateforme dépendant signalée dans la documentation :

https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms706613(v=vs.85).aspx

Je ne vois rien dans votre code pour gérer tout ce merdier."

Mettre des valeurs en dur, ok, mais lesquelles ? le SSID, le mot de passe ?

Et surtout le "Il y a déjà pas mal de trucs plateforme dépendant signalée dans la documentation", hein ? quoi ? quels trucs ?

Je pige pas quels sont ces trucs et ce que je suis censé faire avec, ou comment m'y adapter.

Et sinon mon code il compile mais wlanConnect renvoie INVALID_PARAMETER...

> j'ai voulu le compiler mais ca ne marche pas :

Houais, je sens un petit oubli, cf. la partie "Library       Wlanapi.lib" de la documentation :

https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms706613%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396

Vous avez pas oublié de spécifier la lib qui va bien dans les options de l'éditeur de lien, par hasard ?

>Mettre des valeurs en dur, ok, mais lesquelles ? le SSID, le mot de passe ?

Absolument TOUTES, c'est pour pas ce prendre la tête avec d'autres problèmes que de faire fonctionner ces APIs.

>signalée dans la documentation", hein ? quoi ? quels trucs ?

Tous les trucs en gras dans la documentation de la forme "NomDeLaPlateformeQuiFaitChié:" suivi par un laïus spécifique à la dite plateforme.

>Et sinon mon code il compile mais wlanConnect renvoie INVALID_PARAMETER...

Comme je l'ai déjà signalé

"La documentation donne déjà une liste longue comme le bras de problèmes potentiels."

donc déjà :

ERROR_INVALID_PARAMETER

   

One of the following conditions occurred:

    hClientHandle is NULL or invalid.
    pInterfaceGuid is NULL.
    pConnectionParameters is NULL.
    The dwFlags member of the structure pointed to by pConnectionParameters is not set to one of the values specified on the WLAN_CONNECTION_PARAMETERS page.
    The wlanConnectionMode member of the structure pointed to by pConnectionParameters is set to wlan_connection_mode_discovery_secure or wlan_connection_mode_discovery_unsecure, and the pDot11Ssid member of the same structure is NULL.
    The wlanConnectionMode member of the structure pointed to by pConnectionParameters is set to wlan_connection_mode_discovery_secure or wlan_connection_mode_discovery_unsecure, and the dot11BssType member of the same structure is set to dot11_BSS_type_any.
    The wlanConnectionMode member of the structure pointed to by pConnectionParameters is set to wlan_connection_mode_profile, and the strProfile member of the same structure is NULL or the length of the profile exceeds WLAN_MAX_NAME_LENGTH.
    The wlanConnectionMode member of the structure pointed to by pConnectionParameters is set to wlan_connection_mode_profile, and the strProfile member of the same structure is NULL or the length of the profile is zero.
    The wlanConnectionMode member of the structure pointed to by pConnectionParameters is set to wlan_connection_mode_invalid or wlan_connection_mode_auto.
    The dot11BssType member of the structure pointed to by pConnectionParameters is set to dot11_BSS_type_infrastructure, and the dwFlags member of the same structure is set to WLAN_CONNECTION_ADHOC_JOIN_ONLY.
    The dot11BssType member of the structure pointed to by pConnectionParameters is set to dot11_BSS_type_independent, and the dwFlags member of the same structure is set to WLAN_CONNECTION_HIDDEN_NETWORK.
    The dwFlags member of the structure pointed to by pConnectionParameters is set to WLAN_CONNECTION_IGNORE_PRIVACY_BIT, and either the wlanConnectionMode member of the same structure is not set to wlan_connection_mode_temporary_profile or the dot11BssType member of the same structure is set to dot11_BSS_type_independent.

juste pour vous dire que je continue de suivre le sujet et que je travaille dessus mais que j'ai énormément de travail en 3ème donc c'est normal si je met parfois du temps à répondre.

Courage, et GG si t'es en 3ème, c'est clairement pas du travail de débutant, même pour la fac !!!

Merci beaucoup, et je peux enfin vous répondre !

J'ai réussi à me connecter au wifi de mon choix grâce à ce lien : https://gaiger-programming.blogspot.fr/2015/03/connect-to-specified-wifi-router-by.html

C'est tellement rageant de se dire que on a fait tout ca pour rien que je vais adapter ce code au mien, trouver ce qui ne va pas et le corriger pour que mon code fonctionne... de plus, je trouve que le sien ne donne pas assez d'informations sur les réseaux.

Pourtant, dans mon code, il y a une chose que je ne comprend pas.

Quand je fais ca dans MON code:

WLAN_CONNECTION_PARAMETERS connParam;
	memset(&connParam, 0, sizeof(WLAN_CONNECTION_PARAMETERS));
	connParam.pDot11Ssid = NULL;
	connParam.strProfile = pBssList->Network[0].strProfileName;

	connParam.wlanConnectionMode = wlan_connection_mode_profile;
	connParam.pDesiredBssidList = NULL;

	connParam.dot11BssType = pBssList->Network[0].dot11BssType;
	connParam.dwFlags = 0;

ou même que j'initialise ma structure directement en la créant en une seule ligne, j'ai une exception violation acess memory et tout le blabla.

peu importe ce que je fais, un ZeroMemory, un memset, si  je l'initialise, toujours cette exception... savez vous pourquoi ?

Dans le code que tu donne le seul truc qui peut poser probleme a mon avis, c'est ce qui concerne pbsslist...

non car la première exception je l'ai sur le memset et si je change les valeurs que je met NULL ou 0 l’exception est quand même déclenchée

EDIT : ah quand j'enlève le WlanGetProfile ca marche jusqu'à

connParam.dot11BssType = pBssList->Network[0].dot11BssType;

mais ce qui est étrange c'est que ca :

connParam.strProfile = pBssList->Network[0].strProfileName;

ca passe sans exception et voila l'erreur pour la première :

vous comprenez pourquoi ?

-
Edité par raphaeldesaintalbin 4 octobre 2017 à 16:53:28

Le code que tu donnes est simple mais il est clairement en C et des réglages différents du compilateur peuvent avoir des impacts non négligeables sur le résultat.

Je ne dis pas qu'il est faux, il fait simple et synthétique, mais les goto et les mélanges de printf et de wprintf, ça pique un peu les yeux.

Il ne cherche pas à faire des acrobaties avec les structures passées aux primitives, il utilise plutôt celles que d'autres primitives retournent.

Je pense donc comme @breizhbugs, que pbsslist est foireux.

> je l'ai sur le memset

Alors c'est que vous avez passé des pointeurs foireux à memset.

memset est un fonction des plus simple, bête et méchant.

Utilisez le débogueur pour voir la valeur des paramètres et le contenu de la mémoire pointée par les pointeurs.

décidément, nous postons toujours pile au même moment !

Ce qui est étrange c'est que quand j'enlève le WlanGetProfile du dessus il n'y a plus d’exception acess memory sur la ligne du memset.

et... ou ca des goto ?

-
Edité par raphaeldesaintalbin 4 octobre 2017 à 17:08:47

Tu peu mettre la totalité de ton code actuell svp pour que l'on voit ou tu en es (et je dis bien la totalité svp, pas juste la fonction conexion).

-
Edité par breizhbugs 4 octobre 2017 à 18:21:48

>et... ou ca des goto ?

Un peu partout dans le code de l'article dont vous avez donné l'URL.

Si j'en crois le message d'erreur du débogueur "pBssList" est à nullptr.

Et à ce petit jeu, le débogueur a toujours raison.

Commencez par utiliser un build DEBUG pour avoir plus de "canari" (vérification mémoire) pour vérifier que c'est pas des conneries ailleurs qui foutent le bordel (c'est la joie du C bas niveau).

Utilisez le débogueur, il donne la valeur de chaque variable et de voir le contenu de la mémoire.

@breizhbugs bientôt car il est en "rénovation". petite question : pour transmettre des variables d'une fonction à une autre, quelle est la solution la plus propre (a part return) : déclarer une variable global (je pense que c'est le mieux), utiliser un fichier (flux ofstream, on met la variable dans un fichier et on récupère la valeur dans un autre fichier) ou encore une autre solution ?

@bacelar ah oui, j'ai copié collé un code d'un lien donné par breizhbugs et je n'ai pas encore trop eu le temps de le regarder...

Et je sais que c'est pBssList qui est a nullptr mais pourquoi ça marche trois lignes au dessus ?

raphaeldesaintalbin a écrit:

@breizhbugs bientôt car il est en "rénovation". petite question : pour transmettre des variables d'une fonction à une autre, quelle est la solution la plus propre (a part return) : déclarer une variable global (je pense que c'est le mieux), utiliser un fichier (flux ofstream, on met la variable dans un fichier et on récupère la valeur dans un autre fichier) ou encore une autre solution ?

Euh, les passer en parametre. Et puisque tu es en c++, eventuellement faire une classe et en faire des propriétés?

justement, j'avais voulu faire une classe à un moment mais @bacelar m'avait affirmé que le but d'une classe étant de simplifier le code, ma justification de ma classe était mauvaise étant donné que cela ne ferait que compliquer le code. mais maintenant que j'y vois un peu plus clair dans mon code, peut être que l'utilisation d'une classe serait justifiée ? Je vais tenter ça.

-
Edité par raphaeldesaintalbin 8 octobre 2017 à 10:42:03

> c'est pBssList qui est a nullptr mais pourquoi ça marche trois lignes au dessus ?

Parce que la valeur a changé entre les lignes  dans votre code?

Parce qu'on utilise une API dans le premier cas accepte NULL (attention, nullptr, c'est du C++, pour les API C, préféré le NULL du C, au cas où les langages diverges ou pour faire du code portable).

Parce qu'un traitement asynchrone a changé la valeur pendant que votre processus c'est endormi.

etc...

Montrez votre code, SVP.

alors j'ai compris pourquoi cette erreur, voici le bloc en cause :

	if (pBssList != NULL) {
		WlanFreeMemory(pBssList);
		pBssList = NULL;
	}

je ne l'avais pas vu, caché dans la fonction listWifi.

voici mon code (surement pas très propre surtout la partie listWifi qui regorge de wprintf et autres délicieuses choses mais c'est un code pris a la va-vite sur la doc de mdsn et j'ai la flemme de tout refaire). sur ce, voici mon code :

wifi.cpp :

#include <Windows.h>
#include <wlanapi.h>
#include <iostream>
#include "fonctions.h"
#include <string>
#include <vector>
#include <conio.h>


void main()
{
	Wifi Wifi;
	std::cout << "Pour vous connecter, tapez 1, pour vous deconnecter, tapez 2" << std::endl;
	int choix;
	do
	{
		std::cin >> choix;
	} while (choix != 2 && choix != 2);
	if (choix == 2)
	{
		Wifi.deconnexionWifi();
	}
	else if (choix == 1)
	{
		Wifi.deconnexionWifi();
		Wifi.listWifi();
		std::cout << "vous etes vous deja connecte a ce reseau ?(Y/N)" << std::endl;
		std::string choixCoo;
		do
		{
			std::cin >> choixCoo;
		} while (choixCoo != "N" && choixCoo != "Y");
		DWORD retour(Wifi.connexionWifi(choixCoo));
	}
	std::cout << "Appuyez sur entree pour continuer..." << std::endl;
	_getch();
}

fonctions.cpp

#include <Windows.h>
#include <wlanapi.h>
#include <fstream>
#include <vector>
#include <string>
#include <iostream>
#include "fonctions.h"
// Need to link with Wlanapi.lib and Ole32.lib
#pragma comment(lib, "wlanapi.lib")
#pragma comment(lib, "ole32.lib")

int Wifi::listWifi()
{

	// Declare and initialize variables.
	HANDLE hClient = NULL;
	DWORD dwMaxClient = 2;      //    
	DWORD dwCurVersion = 0;
	DWORD dwResult = 0;
	DWORD dwRetVal = 0;
	int iRet = 0;

	WCHAR GuidString[39] = { 0 };

	unsigned int i, j, k;

	/* variables used for WlanEnumInterfaces  */

	PWLAN_INTERFACE_INFO_LIST pIfList = NULL;
	PWLAN_INTERFACE_INFO pIfInfo = NULL;

	PWLAN_AVAILABLE_NETWORK pBssEntry = NULL;

	int iRSSI = 0;

	dwResult = WlanOpenHandle(dwMaxClient, NULL, &dwCurVersion, &hClient);
	if (dwResult != ERROR_SUCCESS) {
		wprintf(L"WlanOpenHandle failed with error: %u\n", dwResult);
		return 1;
		// You can use FormatMessage here to find out why the function failed
	}

	dwResult = WlanEnumInterfaces(hClient, NULL, &pIfList);
	if (dwResult != ERROR_SUCCESS) {
		wprintf(L"WlanEnumInterfaces failed with error: %u\n", dwResult);
		return 1;
		// You can use FormatMessage here to find out why the function failed
	}
	else {
		for (i = 0; i < (int)pIfList->dwNumberOfItems; i++) {

			pIfInfo = (WLAN_INTERFACE_INFO *)&pIfList->InterfaceInfo[i];
			wprintf(L"  Interface Index[%u]:\t %lu\n", i, i);
			GUID = pIfInfo->InterfaceGuid;
			iRet = StringFromGUID2(pIfInfo->InterfaceGuid, (LPOLESTR)&GuidString,
				sizeof(GuidString) / sizeof(*GuidString));
			// For c rather than C++ source code, the above line needs to be
			// iRet = StringFromGUID2(&pIfInfo->InterfaceGuid, (LPOLESTR) &GuidString, 
			//     sizeof(GuidString)/sizeof(*GuidString)); 
			if (iRet == 0)
				wprintf(L"StringFromGUID2 failed\n");
			else {
				wprintf(L"  InterfaceGUID[%i]: %ws\n", i, GuidString);
			}
			wprintf(L"  Interface Description[%d]: %ws", i,
				pIfInfo->strInterfaceDescription);
			wprintf(L"\n");
			wprintf(L"  Interface State[%d]:\t ", i);
			switch (pIfInfo->isState) {
			case wlan_interface_state_not_ready:
				wprintf(L"Not ready\n");
				break;
			case wlan_interface_state_connected:
				wprintf(L"Connected\n");
				break;
			case wlan_interface_state_ad_hoc_network_formed:
				wprintf(L"First node in a ad hoc network\n");
				break;
			case wlan_interface_state_disconnecting:
				wprintf(L"Disconnecting\n");
				break;
			case wlan_interface_state_disconnected:
				wprintf(L"Not connected\n");
				break;
			case wlan_interface_state_associating:
				wprintf(L"Attempting to associate with a network\n");
				break;
			case wlan_interface_state_discovering:
				wprintf(L"Auto configuration is discovering settings for the network\n");
				break;
			case wlan_interface_state_authenticating:
				wprintf(L"In process of authenticating\n");
				break;
			default:
				wprintf(L"Unknown state %ld\n", pIfInfo->isState);
				break;
			}
			wprintf(L"\n");

			dwResult = WlanGetAvailableNetworkList(hClient,
				&pIfInfo->InterfaceGuid,
				WLAN_AVAILABLE_NETWORK_INCLUDE_ALL_ADHOC_PROFILES,
				NULL,
				&pBssList);

			if (dwResult != ERROR_SUCCESS) {
				wprintf(L"WlanGetAvailableNetworkList failed with error: %u\n",
					dwResult);
				dwRetVal = 1;
				// You can use FormatMessage to find out why the function failed
			}
			else {

				wprintf(L"WLAN_AVAILABLE_NETWORK_LIST for this interface\n");

				wprintf(L"  Num Entries: %lu\n\n", pBssList->dwNumberOfItems);
				for (j = 0; j < pBssList->dwNumberOfItems; j++) {
					pBssEntry =
						(WLAN_AVAILABLE_NETWORK *)& pBssList->Network[j];

					wprintf(L"  Profile Name[%u]:  %ws\n", j, pBssEntry->strProfileName);

					wprintf(L"  SSID[%u]:\t\t ", j);
					wprintf(L"  BSS Network type[%u]:\t ", j);
					switch (pBssEntry->dot11BssType) {
					case dot11_BSS_type_infrastructure:
						wprintf(L"Infrastructure (%u)\n", pBssEntry->dot11BssType);
						break;
					case dot11_BSS_type_independent:
						wprintf(L"Infrastructure (%u)\n", pBssEntry->dot11BssType);
						break;
					default:
						wprintf(L"Other (%lu)\n", pBssEntry->dot11BssType);
						break;
					}

					wprintf(L"  Number of BSSIDs[%u]:\t %u\n", j, pBssEntry->uNumberOfBssids);

					wprintf(L"  Connectable[%u]:\t ", j);
					if (pBssEntry->bNetworkConnectable)
						wprintf(L"Yes\n");
					else {
						wprintf(L"No\n");
						wprintf(L"  Not connectable WLAN_REASON_CODE value[%u]:\t %u\n", j,
							pBssEntry->wlanNotConnectableReason);
					}

					wprintf(L"  Number of PHY types supported[%u]:\t %u\n", j, pBssEntry->uNumberOfPhyTypes);

					if (pBssEntry->wlanSignalQuality == 0)
						iRSSI = -100;
					else if (pBssEntry->wlanSignalQuality == 100)
						iRSSI = -50;
					else
						iRSSI = -100 + (pBssEntry->wlanSignalQuality / 2);

					wprintf(L"  Signal Quality[%u]:\t %u (RSSI: %i dBm)\n", j,
						pBssEntry->wlanSignalQuality, iRSSI);

					wprintf(L"  Security Enabled[%u]:\t ", j);
					if (pBssEntry->bSecurityEnabled)
						wprintf(L"Yes\n");
					else
						wprintf(L"No\n");

					wprintf(L"  Default AuthAlgorithm[%u]: ", j);
					switch (pBssEntry->dot11DefaultAuthAlgorithm) {
					case DOT11_AUTH_ALGO_80211_OPEN:
						wprintf(L"802.11 Open (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					case DOT11_AUTH_ALGO_80211_SHARED_KEY:
						wprintf(L"802.11 Shared (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					case DOT11_AUTH_ALGO_WPA:
						wprintf(L"WPA (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					case DOT11_AUTH_ALGO_WPA_PSK:
						wprintf(L"WPA-PSK (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					case DOT11_AUTH_ALGO_WPA_NONE:
						wprintf(L"WPA-None (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					case DOT11_AUTH_ALGO_RSNA:
						wprintf(L"RSNA (%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					case DOT11_AUTH_ALGO_RSNA_PSK:
						wprintf(L"RSNA with PSK(%u)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					default:
						wprintf(L"Other (%lu)\n", pBssEntry->dot11DefaultAuthAlgorithm);
						break;
					}

					wprintf(L"  Default CipherAlgorithm[%u]: ", j);
					switch (pBssEntry->dot11DefaultCipherAlgorithm) {
					case DOT11_CIPHER_ALGO_NONE:
						wprintf(L"None (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					case DOT11_CIPHER_ALGO_WEP40:
						wprintf(L"WEP-40 (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					case DOT11_CIPHER_ALGO_TKIP:
						wprintf(L"TKIP (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					case DOT11_CIPHER_ALGO_CCMP:
						wprintf(L"CCMP (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					case DOT11_CIPHER_ALGO_WEP104:
						wprintf(L"WEP-104 (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					case DOT11_CIPHER_ALGO_WEP:
						wprintf(L"WEP (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					default:
						wprintf(L"Other (0x%x)\n", pBssEntry->dot11DefaultCipherAlgorithm);
						break;
					}

					wprintf(L"  Flags[%u]:\t 0x%x", j, pBssEntry->dwFlags);
					if (pBssEntry->dwFlags) {
						if (pBssEntry->dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED)
							wprintf(L" - Currently connected");
						if (pBssEntry->dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED)
							wprintf(L" - Has profile");
					}
					wprintf(L"\n");

					wprintf(L"\n");
				}
			}
		}
		int nbReseaux(pBssList->dwNumberOfItems);
		for (int l(0); l < nbReseaux; l++)
		std::string reseauFinal;
			std::cout << "Quel reseau ?" << std::endl;
			do
			{
				std::cin >> numeroReseau;
			} while (numeroReseau > nbReseaux - 1 || numeroReseau < 0);
			std::wstring WSSIDTemp(pBssList->Network[numeroReseau].strProfileName);
			std::string SSIDTemp(WSSIDTemp.begin(), WSSIDTemp.end());
			SSIDReseau = SSIDTemp;
		}
	if (pIfList != NULL) {
		WlanFreeMemory(pIfList);
		pIfList = NULL;
	}
	return dwResult;
}

HANDLE Wifi::recupHandle()
{
	HANDLE varHandle;
	DWORD dwMaxClient = 2;
	DWORD dwCurVersion = 0;
	DWORD dwResult = 0;
	dwResult = WlanOpenHandle(dwMaxClient, NULL, &dwCurVersion, &varHandle);
	if (dwResult != ERROR_SUCCESS) {
		wprintf(L"WlanOpenHandle failed with error: %u\n", dwResult);
	}
	return varHandle;
}

std::wstring s2ws(std::string& s)
{
	int len;
	int slength = (int)s.length() + 1;
	len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
	wchar_t* buf = new wchar_t[len];
	MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
	std::wstring r(buf);
	delete[] buf;
	return r;
}

DWORD Wifi::connexionWifi(std::string choixCoo)
{
	HANDLE handle(recupHandle());
	LPCWSTR profilXML(creerProfil(choixCoo, "\0"));
	DWORD dwFlags;
	DWORD dwGrantedAccess;
	LPWSTR xml;
	DWORD retour;

	WLAN_CONNECTION_PARAMETERS connParam;
	ZeroMemory(&connParam, sizeof(WLAN_CONNECTION_PARAMETERS));
	connParam.pDot11Ssid = NULL;
	connParam.strProfile = pBssList->Network[0].strProfileName;

	connParam.wlanConnectionMode = wlan_connection_mode_profile;
	connParam.pDesiredBssidList = NULL;

	connParam.dot11BssType = pBssList->Network[0].dot11BssType;
	connParam.dwFlags = 0;
	DWORD error;
	/*
	if ((error = WlanRegisterNotification(handle, WLAN_NOTIFICATION_SOURCE_ALL, true, (WLAN_NOTIFICATION_CALLBACK)Wifi::WlanNotification, &Wifi::WlanNotification, 0, &dwReason)) != ERROR_SUCCESS)
	{
		std::cout << "WlanRegisterNotification a echoue\n" << std::endl;
		switch (error)
		{
		case ERROR_INVALID_HANDLE:
			std::cout << "handle invalide" << std::endl;
			break;
		case ERROR_NOT_ENOUGH_MEMORY:
			std::cout << "pb memoire" << std::endl;
			break;
		case ERROR_INVALID_PARAMETER:
			std::cout << "parametre invalide" << std::endl;
			break;
		}
	}*/
	if (pBssList != NULL) {
		WlanFreeMemory(pBssList);
		pBssList = NULL;
	}
	error = WlanConnect(handle, &GUID, &connParam, NULL);
	if (error != ERROR_SUCCESS)
	{
		std::cout << "La demande de connexion a echoue\n" << std::endl;
		switch (error)
		{
		case ERROR_INVALID_HANDLE:
			std::cout << "Handle invalide" << std::endl;
			break;
		case ERROR_ACCESS_DENIED:
			std::cout << "Acces refusé" << std::endl;
			break;
		case ERROR_INVALID_PARAMETER:
			std::cout << "Parametre invalide" << std::endl;
			break;
		}
	}
	else
	{
		std::cout << "La demande de connexion reussi\n" << std::endl;
	}
	return error;
}

void Wifi::deconnexionWifi()
{
	HANDLE handleDeco(recupHandle());
	WlanDisconnect(handleDeco, &GUID, NULL);
}

LPWSTR Wifi::creerProfil(std::string choix, std::string password)
{
	//HANDLE
	HANDLE handle(recupHandle());

	//retour
	DWORD dwReason;

	//SSID
	std::wstring stringTemp = s2ws(SSIDReseau);
	LPCWSTR strProfileXML(stringTemp.c_str());
	

	//autre
	LPWSTR profileXML;
	DWORD error;
	if (choix == "N")
	{

		wchar_t profileXMLUnicode[4096];
		char buff[4096];
		char profileTemplateXML[] = "<?xml version=\"1.0\"?>" \
			"<WLANProfile xmlns=\"http://www.microsoft.com/networking/WLAN/profile/v1\">"\
			" <name>%s</name>" \
			"       <SSIDConfig> " \
			"                <SSID>" \
			"                        <name>%s</name>"\
			"                </SSID>"\
			"        </SSIDConfig>"\
			"        <connectionType>ESS</connectionType>"\
			"        <connectionMode>auto</connectionMode>"\
			"        <MSM>"\
			"                <security>"\
			"                        <authEncryption>"\
			"                                <authentication>%s</authentication>"\
			"                                <encryption>%s</encryption>"\
			"                                <useOneX>false</useOneX>"\
			"                        </authEncryption>"\
			"                        <sharedKey>"\
			"                                <keyType>passPhrase</keyType>"\
			"                                <protected>false</protected>"\
			"                                <keyMaterial>%s</keyMaterial>"\
			"                        </sharedKey>"\
			"                </security>" \
			"        </MSM>" \
			"</WLANProfile>";

		char authentication[64];
		char encryption[64];
		memset(&authentication[0], 0, 64);
		memset(&encryption[0], 0, 64);
		switch (pBssList->Network[numeroReseau].dot11DefaultAuthAlgorithm)
		{
		case DOT11_AUTH_ALGO_80211_OPEN:
			sprintf(&authentication[0], "OPEN");
			break;
		case DOT11_AUTH_ALGO_80211_SHARED_KEY:
			sprintf(&authentication[0], "WEP");
			break;

		case DOT11_AUTH_ALGO_WPA:
		case DOT11_AUTH_ALGO_WPA_PSK:
		case DOT11_AUTH_ALGO_WPA_NONE:
			sprintf(&authentication[0], "WPAPSK");
			break;

		case DOT11_AUTH_ALGO_RSNA:
		case DOT11_AUTH_ALGO_RSNA_PSK:
			sprintf(&authentication[0], "WPA2PSK");
			break;

		default:
			sprintf(&authentication[0], "UNKNOWN");
			break;
		}
		switch (pBssList->Network[numeroReseau].dot11DefaultCipherAlgorithm)
		{
		case DOT11_CIPHER_ALGO_NONE:
			sprintf(&encryption[0], "NOEN");
			break;

		case DOT11_CIPHER_ALGO_TKIP:
			sprintf(&encryption[0], "TKIP");
			break;

		case DOT11_CIPHER_ALGO_CCMP:
			sprintf(&encryption[0], "AES");
			break;
		default:
			sprintf(&encryption[0], "WEP");
			break;
		}
		sprintf(buff, profileTemplateXML, pBssList->Network[numeroReseau].dot11Ssid.ucSSID,
			pBssList->Network[numeroReseau].dot11Ssid.ucSSID,
			&authentication[0], &encryption[0], password);

		/*Covert ansi to unicode*/
		MultiByteToWideChar(CP_ACP, 0, &buff[0], -1, &profileXMLUnicode[0], 4096);
		if ((error = WlanSetProfile(handle, &GUID, 0, profileXMLUnicode, NULL, TRUE, NULL, &dwReason)) == ERROR_SUCCESS)
		{
			std::cout << "Profil cree !\n" << std::endl;
		}
		else
		{
			std::cout << "Echec lors de la creation du profil !\n" << std::endl;
			switch (error)
			{
			case ERROR_ALREADY_EXISTS:
				printf("PROFILE ALREADY EXIST\n");
				break;
			case ERROR_ACCESS_DENIED:
				printf("NO PERMISSION TO CONNECT\n");
				break;
			case ERROR_INVALID_PARAMETER:
				printf("INVALID PARAMETERS\n");
				break;
			case ERROR_BAD_PROFILE:
				printf("THE PROFILE IS INVALID\n");
				break;
			case ERROR_NO_MATCH:
				printf("SOMETHING DON'T MATCH\n");
				break;
			}

		}
	}
	if ((error = WlanGetProfile(handle, &GUID, strProfileXML, NULL, &profileXML, NULL, NULL)) == ERROR_SUCCESS)
	{
		std::cout << "profil recupere !\n" << std::endl;
	}
	else
	{
		std::cout << "Echec lors de la recuperation du profil !\n" << std::endl;
	}
	switch (error)
	{
	case ERROR_INVALID_HANDLE:
		printf("INVALID HANDLE\n");
		break;
	case ERROR_ACCESS_DENIED:
		printf("NO PERMISSION TO CONNECT\n");
		break;
	case ERROR_INVALID_PARAMETER:
		printf("INVALID PARAMETERS\n");
		break;
	case ERROR_NOT_ENOUGH_MEMORY:
		printf("NOT ENOUGH MEMORY");
		break;
	case ERROR_NOT_FOUND:
		printf("PROFILE NOT FOUND");
		break;
	}
	return profileXML;
}

void Wifi::WlanNotification(WLAN_NOTIFICATION_DATA *wlanNotifData, VOID *p)
{
	WCHAR buffer[100];
	switch (wlanNotifData->NotificationCode)
	{
	case wlan_notification_acm_start:
		printf("wlan_notification_acm_start\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_autoconf_enabled:
		printf("wlan_notification_acm_autoconf_enabled\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_autoconf_disabled:
		printf("wlan_notification_acm_autoconf_disabled\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_background_scan_enabled:
		printf("wlan_notification_acm_background_scan_enabled\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_background_scan_disabled:
		printf("wlan_notification_acm_background_scan_disabled\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_bss_type_change:
		printf("wlan_notification_acm_bss_type_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_power_setting_change:
		printf("wlan_notification_acm_power_setting_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_scan_complete:
		printf("wlan_notification_acm_scan_complete\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_scan_fail:
		printf("wlan_notification_acm_scan_fail\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_connection_start:
		printf("wlan_notification_acm_connection_start\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_connection_complete:
		printf("wlan_notification_acm_connection_complete\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_connection_attempt_fail:
		printf("wlan_notification_acm_connection_attempt_fail\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_filter_list_change:
		printf("wlan_notification_acm_filter_list_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_interface_arrival:
		printf("wlan_notification_acm_interface_arrival\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_interface_removal:
		printf("wlan_notification_acm_interface_removal\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_profile_change:
		printf("wlan_notification_acm_profile_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_profile_name_change:
		printf("wlan_notification_acm_profile_name_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_profiles_exhausted:
		printf("wlan_notification_acm_profiles_exhausted\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_network_not_available:
		printf("wlan_notification_acm_network_not_available\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_network_available:
		printf("wlan_notification_acm_network_available\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_disconnecting:
		printf("wlan_notification_acm_disconnecting\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_disconnected:
		printf("wlan_notification_acm_disconnected\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_adhoc_network_state_change:
		printf("wlan_notification_acm_adhoc_network_state_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_profile_unblocked:
		printf("wlan_notification_acm_profile_unblocked\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_screen_power_change:
		printf("wlan_notification_acm_screen_power_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_profile_blocked:
		printf("wlan_notification_acm_profile_blocked\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_scan_list_refresh:
		printf("wlan_notification_acm_scan_list_refresh\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_operational_state_change:
		printf("wlan_notification_acm_operational_state_change\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	case wlan_notification_acm_end:
		printf("wlan_notification_acm_end\n");
		WlanReasonCodeToString(reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA> (wlanNotifData->pData)->wlanReasonCode, 100, buffer, NULL);
		wprintf(L"%s\n", buffer);
		memset(buffer, 0, sizeof(buffer));
		break;
	}
}

fonctions.h

#ifndef FONCTIONS_H_INCLUDED
#define FONCTIONS_H_INCLUDED

#include <vector>

class Wifi {
public :
	int listWifi();
	HANDLE recupHandle();
	DWORD connexionWifi(std::string choixCoo);
	void deconnexionWifi();
	LPWSTR creerProfil(std::string choix, std::string password);
	void WlanNotification(WLAN_NOTIFICATION_DATA *wlanNotifData, VOID *p);

private :
	GUID GUID;
	PWLAN_AVAILABLE_NETWORK_LIST pBssList = NULL;
	HANDLE handle;
	int numeroReseau;
	std::string SSIDReseau;
};

std::wstring s2ws(std::string& s);

#endif // FONCTIONS_H_INCLUDED

(désolé c'est un peu long...)

-
Edité par raphaeldesaintalbin 10 octobre 2017 à 15:38:16

>j'ai la flemme de tout refaire

Moi, j'aurais eu la flemme de déboguer à l'ancienne.

J'aurais remplacé les "wprint" et autre "return 1" par une simple "throw exception" qui va bien.

3 secondes et demie contre les heures de degugging, le calcul est vite vu.

Votre classe "Wifi" fait trop de chose.

La gestion de la liste des Wifi disponibles devrait être dans une classe à part ou dans un ensemble de fonctions libres (regroupés dans un namespace par exemple) plutôt qu'en méthode/fonction membre (voir gérer cela avec des méthodes statiques).

Cela rendrait le code bien plus clair.

Pour les chaines de caractère en dur (c'est pas bien), utilisez systématiquement le type TCHAR à la place de char et la MACRO TEXT ou _T.

Fonctions beaucoup beaucoup trop longue, facilement factorisable, et utilisation de fonctions à la place du copier-coller de bourrin.

Vous n'indiquez pas si le code fonction ou, s'il ne fonctionne pas, où il déconne.

J'ai pas tout lu, mais ligne 124, "uneWstring" est initialisée où ?

@bacelar

> J'aurais remplacé les "wprint" et autre "return 1" par une simple "throw exception" qui va bien.

AH ! Mais ca me fais une erreur d'implémentation bien que j'ai pas bien compris ce que je devais lancer et faire avec vos throw...

> La gestion de la liste des Wifi disponibles devrait être dans une classe à part ou dans un ensemble de fonctions libres (regroupés dans un namespace par exemple) plutôt qu'en méthode/fonction membre (voir gérer cela avec des méthodes statiques).

D'accord mais je fais comment pour passer une variable/structure d'une fonction à une autre ? en les passant en paramètre ?

> Vous n'indiquez pas si le code fonction ou, s'il ne fonctionne pas, où il déconne.

euh bah INVALID_PARAMETER renvoyé par WlanConnect

> J'ai pas tout lu, mais ligne 124, "uneWstring" est initialisée où ?

effectivement, j'ai fais une erreur dans mon code, j'ai enlevé quelques lignes qui étaient parfaitement inutiles et pas propres.

j'édite mon dernier message afin de vous montrer la dernière version de mon code.

Raphael

Soit vous faites du C, soit vous faites du C++.

Ici, le mixte des 2, ça rend l'analyse bordélique.

Vous utilisez les traces et les codes retours à la C et vous initialisez vos variables à la C++ et vous ne traitez pas les valeurs retournées parce que vous vous croyez en C++, même si la fonction utilise des codes retours donc à traiter comme en C.

Le fait de mélanger ces langages rend votre code difficile à maintenir.

Vous faites du C++, alors circonscrivez le code "à la C" dans des fonctions qui ont une API à la C++, donc avec des exceptions ou des asserts.

Avec ce mélange, les erreurs se produisent des kilomètres après une détection des problèmes, simplifiez-vous la vie, envoyez moi ces putains d'exception plutôt que ces cochonneries de "print + code retour", RIGHT NOW.

Cas pathologique de ces conneries : "Wifi::recupHandle"

HANDLE Wifi::recupHandle()
{
    HANDLE varHandle;
    DWORD dwMaxClient = 2;
    DWORD dwCurVersion = 0;
    DWORD dwResult = 0;
    dwResult = WlanOpenHandle(dwMaxClient, NULL, &dwCurVersion, &varHandle);
    if (dwResult != ERROR_SUCCESS) {
        throw runtime_error(dwResult,std::generic_category());
    }
    return varHandle;
}

C'est pas la fin du monde, c'est juste un pauvre copier-coller et vous pouvez vous servir CORRECTEMENT de cette méthode qui a une API C++ et plus cet infâme API C que vous n'utilisiez même pas correctement.

>D'accord mais je fais comment pour passer une variable/structure ...passant en paramètre ?

Bin, comme d'hab, avec la méthode la plus adaptée à votre conception, argument d'une fonction ou champ d'une instance de classe, ou tout autre moyen cohérent avec la sémantique du machin.

Vous mettez la charrue avant les bœufs, concevez vos classes avant des les implémenter, parce que là, les classes, c'est plus gênant qu'autres choses. En C++, vous n'êtes pas obligé d'utiliser des classes, si elles n'apportent rien.

>j'édite mon dernier message afin de vous montrer la dernière version de mon code.

NON !!!

Cela devient incompréhensible pour nous et encore plus pour les futurs lecteurs qui cherchent des solutions.

>euh bah INVALID_PARAMETER renvoyé par WlanConnect

Ligne 317 ?

Tu m'étonnes, c'est un peu la foire à la saucisse ce bout de code.

Ne recopiez pas bêtement le code.

GUID, une variable globale ou un champ qui ait initialisé à l'arrache, par effet, de bord ligne 54, dans une boucle.

Il a quoi comme saveur particulière ce dernier GUID pour qu'on s'en foute des autres ?

Je ne vois rien qui renforce la cohérence entre les différents paramètres que vous enfournez dans l'API Win32.

Le rapport entre le dernier GUID (valeur actuellement utilisée) et "pBssList->Network[0]" ???

Même si votre code était tombé en marche, il n'est pas maintenable en l'état.

Refactorez votre code.

Vous devez modéliser les objets que vous comptez utilise (Cartes d'interfaces, Reseaux Wifi, etc..) et avoir une classe par type d'objet.

Le passage de variable, c'est vraiment pas un problème.

Hem...

je dois avouer que je m'attendais un peu à cette réaction...

j'avais bien vu que mon code n'était pas propre mais je n'avais pas bien compris comment le nettoyer.

Justement, votre code ne compile pas, le compilo me répond que runtime_error n'est pas déclaré.

ou alors je n'ai pas compris... Je n’utilise surement pas assez les exceptions et étant un novice en c++, je sais que je ne les maitrises pas bien.

Selon vous je devrais détruire ma classe et remettre mon code comme avant ? et donc passer les variables à transmettre d'une fonction à une autre par un autre moyen ?

enfin bon, pour l'instant je vais essayer de nettoyer mon code et on verra pour WlanConnect après...

-
Edité par raphaeldesaintalbin 12 octobre 2017 à 11:01:43

Désolé, mais en fin de journée, on est plus cassant, rien de vraiment personnel.

Je pense que vous avez largement passé le stade du projet jouet qu'on fait en quelques minutes, pour tester un truc.

Il faudrait donc commencer par un peu de conception.

Et moi, dans votre code, je vois pas où commence les traces de conceptions. J'ai donc un mal de chien à utiliser mes réflexes de programmeurs, car je vois des peaux de bananes partout. C'est peut-être pas des erreurs, mais peut-être que si et encore pire des erreurs potentiels qui n'attendent que le pire moment pour se déclencher (loi de Murphy inside).

Après une réflexion de 2 minutes sur votre code, je me dis que l'utilisation de 4 classes simplifierait quand même grandement tout ce capharnaüm de plusieurs centaines de ligne.

Un namespace "wifi" par exemple.

Contenant les classes :

-Wlan (peut-être en utilisant le Design Pattern "Singleton"), qui gèrerait l'utilisation du handle du Wlan, donc appel de "WlanOpenHandle" dans son constructeur et le "WlanCloseHandle" dans son destructeur (ce que ne fait jamais votre code spaghetti qui ouvre des pelletées d'handle sans jamais un fermé un seul).

-"Interface" qui gèrerait les "WLAN_INTERFACE_INFO" associés à une Interface. Wlan pourra, par exemple, implémenter une méthode getInterfaceList() qui fournirait l'ensemble des Interfaces du réseau sous forme d'une liste d'objet "Interface".

-Network qui gèrerait les "WLAN_AVAILABLE_NETWORK" associés à un réseau Wifi. "Interface" pourra, par exemple, implémenter une méthode getNetworkList() qui fournirait l'ensemble des réseaux Wifi accessibles depuis cette interface réseau sous forme d'une liste d'objet Network.

-Profile qui gèrerait, bin les profile .

Déjà, avec ces 4 classes, avec très peu de données dans chacune, peu de services offerts pour chacune, vous pouvez exploser ce code en des bouts bien plus facilement gérables.

Toutes vos rustines, comme cet horrible "recupHandle" devrait disparaitre.

L'utilisation basique d'envoi d'exception supprimerait plusieurs dizaines de lignes complètement useless comme les lignes 481 à 498, etc... qui se résumerait en une ligne : "throw runtime_error(error,std::generic_category());"

Et ne vous obligerait pas à faire une vérification correcte, donc exhaustive et systématique, des code retour (ce que vous ne faites pas de toute façon)

>Justement, votre code ne compile pas, le compilo me répond que runtime_error n'est pas déclaré.

RTFM

http://en.cppreference.com/w/cpp/error/runtime_error

=>Defined in header <stdexcept>

>Je n’utilise surement pas assez les exceptions

C'est bien dommage, ça rend le code plus concis et bien plus simple.

>je sais que je ne les maitrises pas bien.

Il n'y a pas grand-chose à savoir.

>Selon vous je devrais détruire ma classe et remettre mon code comme avant ?

Je sais pas, mais une mauvaise classe, c'est pire que pas de classe du tout.

Essayez déjà avec le jeu de 4 classes que j'ai données.

Normalement, leur implémentation devrait "couler de source".

>et donc passer les variables à transmettre d'une fonction à une autre par un autre moyen ?

Peut-être, si vous le faite bien.

Au vu du manque de rigueur du code, je suis pas sûr que vous le feriez correctement (vérification des code retour, etc...)

>et on verra pour WlanConnect après...

Tout à fait, mais normalement, l'implémentation du code des 4 classes, c'est du copier-coller en nettoyant le code de tous ces machines à effets de bord tout moisi.

Si vous avez du mal à commencer, je vous ferais l'implémentation de Wlan en mode "à l'arrache".