Détection branchement USB

Bonjour,

j'ai un petit problème avec la fonction de détection de branchement de clef USB

J'arrive à détecter quand la clef est branchée ou débranchée, mais je n'arrive pas à savoir le nom du lecteur (E: ou F: ou...)

J'ai trouvé une source en C# qui fonctionne, et une autre en C++ qui ne récupère pas le nom du lecteur.

Je souhaiterais, que mon code en C++ sache faire la même chose que le C#.

Je suis sous Dev C++, Windows XP.

C++

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
// Code par KarLKoX
#include <windows.h>
#include <stdio.h>
 
#ifndef WM_DEVICECHANGE
#define WM_DEVICECHANGE           0x219
#endif
 
#ifndef DBT_DEVICEARRIVAL
#define DBT_DEVICEARRIVAL         0x8000
#endif
 
#ifndef DBT_DEVICEREMOVECOMPLETE
#define DBT_DEVICEREMOVECOMPLETE  0x8004
#endif
 
#ifndef DBT_DEVTYP_VOLUME
#define DBT_DEVTYP_VOLUME         0x2
#endif
 
/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
 
/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";
 
// structure générique
struct DEV_BROADCAST_HDR
{
       int dbch_size;
       int dbch_devicetype;
       int dbch_reserved;
};
 
// structure spécifique
// notez qu'elle a strictement le même tronche que la générique mais
// avec des trucs en plus
struct DEV_BROADCAST_VOLUME
{
       int dbcv_size;
       int dbcv_devicetype;
       int dbcv_reserved;
       int dbcv_unitmask;
       short dbcv_flags;
};
 
 
int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)
 
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */
 
    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);
 
    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
 
    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;
 
    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );
 
    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);
 
    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }
 
    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}
 
 
/*  This function is called by the Windows function DispatchMessage()  */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        // Bonus :)
        case WM_DEVICECHANGE:
             if (wParam == DBT_DEVICEARRIVAL)
                MessageBox(hwnd, "Une clé USB vient d'être connectée.", "Info", MB_OK);
             else if (wParam == DBT_DEVICEREMOVECOMPLETE)
                MessageBox(hwnd, "Une clé USB vient d'être déconnectée.", "Info", MB_OK);
             break;
 
        case WM_ENDSESSION:
            MessageBox(hwnd, "Windows va se fermer.", "Info", MB_OK);
            return 0;
 
        case WM_DESTROY:
            PostQuitMessage (0);       // send a WM_QUIT to the message queue
            break;
 
        default:                      // for messages that we don't deal with
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
protected override void WndProc(ref Message m)
		{
			// le message est de type DEVICECHANGE, ce qui nous interesse
			if (m.Msg == WM_DEVICECHANGE)
			{
				// le "sous-message" dit que le device vient d'etre pluggé
				if (m.WParam.ToInt32() == DBT_DEVICEARRIVAL)
				{
					// device plugged
 
					// on créé une structure depuis un pointeur a l'aide du Marshalling
					// cette structure est generique mais on peut "l'interroger" comme une structure DEV_BROADCAST_HDR
					DEV_BROADCAST_HDR hdr = (DEV_BROADCAST_HDR)Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_HDR));
 
					// ok, le device pluggé est un volume (aussi appelé 'périphérique de stockage de masse')...
					if (hdr.dbch_devicetype == DBT_DEVTYP_VOLUME)
					{
						// ... et donc on recréé une structure, a partir du même pointeur de structure "générique",
						// une structure un poil plus spécifique
						DEV_BROADCAST_VOLUME vol = (DEV_BROADCAST_VOLUME)Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_VOLUME));
						// le champs dbcv_unitmask contient la ou les lettres de lecteur du ou des devices qui viennent d'etre pluggé
						// MSDN nous dit que si le bit 0 est à 1 alors le lecteur est a:, si le bit 1 est à 1 alors le lecteur est b:
						// et ainsi de suite
						uint mask = vol.dbcv_unitmask;
						// recupèration des lettres de lecteurs
						char[] letters = MaskDepioteur(mask);
 
						// mise à jour de l'IHM pour notifier nos petits yeux tout content :)
						this.Text = string.Format("USB key plugged on drive {0}:", letters[0].ToString().ToUpper());
					}
				}
				// le device vient d'etre retirer bourrinement ou proprement
				// (ce message intervient même quand on défait la clef softwarement mais qu'elle reste physiquement branché)
				else if (m.WParam.ToInt32() == DBT_DEVICEREMOVECOMPLETE)
				{
					// device removed
 
					// mise à jour de l'IHM
					this.Text = "USB key unplugged";
				}
			}
 
			// laissons notre fenêtre faire tout de même son boulot
			base.WndProc(ref m);
		}
 
		// fonction d'extraction des lettres de lecteur
		public static char[] MaskDepioteur(uint mask)
		{
			int cnt = 0;
			uint temp_mask = mask;
 
			// on compte le nombre de bits à 1
			for (int i = 0; i < 32; i++)
			{
				if ((temp_mask & 1) == 1)
					cnt++;
				temp_mask >>= 1;
				if (temp_mask == 0)
					break;
			}
 
			// on instancie le bon nombre d'elements
			char[] result = new char[cnt];
			cnt = 0;
			// on refait mais ce coup ci on attribut
			for (int i = 0; i < 32; i++)
			{
				if ((mask & 1) == 1)
					result[cnt++] = (char)('a' + i);
				mask >>= 1;
				if (mask == 0)
					break;
			}
 
			return (result);
		}
	}
 
	// structure générique
	public struct DEV_BROADCAST_HDR
	{
		public uint dbch_size;
		public uint dbch_devicetype;
		public uint dbch_reserved;
	}
 
	// structure spécifique
	// notez qu'elle a strictement le même tronche que la générique mais
	// avec des trucs en plus
	public struct DEV_BROADCAST_VOLUME
	{
		public uint dbcv_size;
		public uint dbcv_devicetype;
		public uint dbcv_reserved;
		public uint dbcv_unitmask;
		public ushort dbcv_flags;
	}

J'ai essayer d'apadter cette partie du C# en C++ mais rien n'y fait...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// on créé une structure depuis un pointeur a l'aide du Marshalling
					// cette structure est generique mais on peut "l'interroger" comme une structure DEV_BROADCAST_HDR
					DEV_BROADCAST_HDR hdr = (DEV_BROADCAST_HDR)Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_HDR));
 
					// ok, le device pluggé est un volume (aussi appelé 'périphérique de stockage de masse')...
					if (hdr.dbch_devicetype == DBT_DEVTYP_VOLUME)
					{
						// ... et donc on recréé une structure, a partir du même pointeur de structure "générique",
						// une structure un poil plus spécifique
						DEV_BROADCAST_VOLUME vol = (DEV_BROADCAST_VOLUME)Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_VOLUME));
						// le champs dbcv_unitmask contient la ou les lettres de lecteur du ou des devices qui viennent d'etre pluggé
						// MSDN nous dit que si le bit 0 est à 1 alors le lecteur est a:, si le bit 1 est à 1 alors le lecteur est b:
						// et ainsi de suite
						uint mask = vol.dbcv_unitmask;
						// recupèration des lettres de lecteurs
						char[] letters = MaskDepioteur(mask);
 
						// mise à jour de l'IHM pour notifier nos petits yeux tout content :)
						this.Text = string.Format("USB key plugged on drive {0}:", letters[0].ToString().ToUpper());
					}

Help !!!! :help: