Lire/Ecrire dans un device depuis un driver[IRP]

**Voldemort09** · 22/02/2009, 19h55

Salut, j'ai enregistré un périférique depuis mon driver et ouvert un handle sur ce fichier depuis le mode utilisateur. Dans le but d'assurer la communication entre les deux programme. J'ai trouvé dans un livre l'exemple suivant pour IOCTL:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
NTSTATUS MyIOControl(IN PDEVICE DeviceObject, IN PIRP Irp)
{
       PIO_STACK_LOCATION IrpSp;
       ULONG FonctionCode;
       IrpSp = IoGetCurrentIrpStackLocation(Irp);
       FonctionCode = IrpSp->Parameters.DeviceIOControl.IOControlCode;
       switch(FonctionCode)
       {
       }
       return STATUS_SUCCESS;
}

[...]

DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = MyIOControl;

Alors, j'ai plusieurs question:

1. Cette fonction(plus haut) recois dans l'IRP les arguments de quel fonctions envoyer par le programme Utilisateur ?

Question plus importante:

2. Avec quoi puis-je récupérer les arguments donné par WriteFile ?

3. Comment est-ce que(depuis le driver) j'écris dans le périférique de façon é ce que le programme Utilisateur puisse lire les donnée avec ReadFile ?

Merci d'avance !

**Melem** · 23/02/2009, 15h01

1. Les arguments de DeviceIoControl . Compare un peu les arguments requis par DeviceIoControl et les champs de la structure IRP et tu y verras plus clair.

2. CreateFile, WriteFile, ReadFile, CloseFile, etc. sont des cas particuliers de DeviceIoControl. Quand WriteFile est appelée, elle envoie au pilote un IRP avec pour control code IRP_MJ_WRITE.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

DriverObject->MajorFunction[IRP_MJ_WRITE] = MyWriteFile;

Indique à ton pilote (qui est, je le rappelle, représenté par "l'objet" DriverObject) d'appeler la fonction MyWriteFile sur réception d'une requête "Write".

3. Implémenter IRP_MJ_READ ...

**Voldemort09** · 23/02/2009, 17h40

1. Oui merci j'ai compris ! J'ai comparer les arguments et les objets dans la structure IRP, et j'ai tout de suite trouvé la correspondance !

2.

2. CreateFile, WriteFile, ReadFile, CloseFile, etc. sont des cas particuliers de DeviceIoControl. Quand WriteFile est appelée, elle envoie au pilote un IRP avec pour control code IRP_MJ_WRITE.

Oui ça, j'ai compris mais je récupère cette IRP ? Je sais qu'il est dans la structure, mais je sais pas où... J'ai chercher des info sur le msdn: http://msdn.microsoft.com/en-us/library/ms795960.aspx mais je n'ai rien trouvé qui puisse m'aider(en faite j'ai juste besoin des arguments passé par WriteFile pour communiquer avec le Driver).

3. Donc faire une fonction MyRead qui écrive dans la structure IRP et qui est réceptionné par ReadFile au niveau utilisateur. Alors deux question me vienne à l'ésprit:
Dans quel objet de la structure IRP j'écrit pour passer ces argument à ReadFile ?
Comment je sais quel argument sont lu au niveau noyau/utilisateur ? Les nouvelle donnée efface les ancienne ou commet est-ce que cela ce passe ?

4. Sinon un dernière question vite-fait: A quoi cela sert-il de faire des fonction pour IRP_MJ_CLOSE et IRP_MJ_CREATE ?

**Melem** · 24/02/2009, 07h48

1. Tu vois !

2. TU ne recois pas directement la requête. C'est le pilote qui le reçoit. Tu dois juste dire à ton pilote que lorsqu'il reçoit un IRP de fonction majeure IRP_MJ_WRITE, il doit appeler la fonction que tu as spécifiée dans DriverObject->MajorFunction[IRP_MJ_WRITE], dans notre cas MyWriteFile. C'est ensuite à l'intérieur de cette fonction que tu implémentes WriteFile. Le prototype que doit respecter cette fonction est indiquée dans la doc du DDK. La structure IRP, entre autres, est passée en argument de la fonction.

3. Il y a un champ qui s'appelle Buffer ou quelque chose du genre dans la structure IRP (IRP.Parameters.Buffer je crois, je ne me rappelle plus). C'est ce buffer que tu dois lire pour récupérer les données transmises par WriteFile et écrire pour transmettre des données à ReadFile. Il existe 3 modes de communications :

- Mode direct : Le Buffer désigné dans la structure IRP n'est autre que le buffer même qui fut passé à WriteFile/ReadFile. Tu as donc accès au Buffer de l'utilisateur.

- Mode bufferisé : Le pilote utilise un buffer "perso". Il y a donc toujours copie des données à chaque lecture ou écriture.

- Mode ni direct ni bufferisé : je ne me rappelle plus en quoi ça consiste vu que j'ai rarement utilisé (si j'ai déjà utilisé

).

4. Patience, tu découvriras avec l'expérience

.

**Voldemort09** · 24/02/2009, 20h54

2-3. Alors, je pense avoir compris mais mes tests n'ont pas été concluant. J'ai choisie la methode directe(jai trouvé un sample sur internet, un site en chinois que j'ai eu du mal a dénicher

).
J'ai mi en pièce jointe le code source du driver(compiler avec le WDK) et de programme utilisateur(compiler avec VC++).
Voici comment j'ai procéder pour mes test: Redémarrage du PC>Ouverture de CodeView(pour récupérer les paramètre de DbgPrint)>Lancement du driver(avec LoadDrv)[A ce moment je reçois bien la confirmation qu'il est correctement charger via les sortit DBG de CodeView]>Lancement du programme utilisateur qui écrit dans le Handle du Device préalablement créer par le Driver.

Mais je ne recois rien dans CodeView(alors que le Driver envoie les info contenu dans les IRP par la sortie DBG(via DbgPrint)...

4. Ok, merci, c'est vrai wue j'ai le temps d'arrendre je n'ai que 14 ans

Code main.c :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdlib.h>
#include <stdio.h>
#include <Windows.h>

char Directory[515];
DWORD dwReturn;

int main()
{
	HANDLE hDevice = CreateFile("\\\\.\\IRP_Communication",
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);
	if (hDevice == ((HANDLE)-1)) return FALSE;

	WriteFile(hDevice, "Hello Kernel from the RING_3!", sizeof("Hello Kernel from the RING_3!"), &dwReturn, NULL); 
    //CloseHandle(hDevice);
	
	printf("Presse [ENTER] to finish the programme...");
	getchar();
	return 0;
}

Code Drvmain.c :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include "ntddk.h"

DRIVER_UNLOAD OnUnload;

NTSTATUS MyIoControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyClose(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyRead(PDEVICE_OBJECT DeviceObject, PIRP Irp);

int IsStringTerminated(PCHAR pString, unsigned int uiLength);
void OnUnload(IN PDRIVER_OBJECT DriverObject);

int state;
NTSTATUS NtStatus = STATUS_SUCCESS;
PDEVICE_OBJECT pDeviceObject = NULL;
UNICODE_STRING usDriverName, usDosDeviceName;


NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING theRegistryPath)
{
	DbgPrint("I loaded!\n");
	
    RtlInitUnicodeString(&usDriverName, L"\\Device\\IRP_Communication");
    RtlInitUnicodeString(&usDosDeviceName, L"\\DosDevices\\IRP_Communication");
	NtStatus = IoCreateDevice(pDriverObject, 0, &usDriverName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDeviceObject);

	pDriverObject->MajorFunction[IRP_MJ_CLOSE]             = MyClose;
	pDriverObject->MajorFunction[IRP_MJ_CREATE]            = MyCreate;
	pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]    = MyIoControl;
	pDriverObject->MajorFunction[IRP_MJ_READ]              = MyRead;
	pDriverObject->MajorFunction[IRP_MJ_WRITE]             = MyWrite;
	IoCreateSymbolicLink(&usDosDeviceName, &usDriverName);
		
	pDriverObject->DriverUnload  = OnUnload;
	
	return STATUS_SUCCESS;
}

void OnUnload(IN PDRIVER_OBJECT DriverObject)
{
	DbgPrint("OnUnload called\n");
}

NTSTATUS MyWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    PIO_STACK_LOCATION pIoStackIrp = NULL;
    PCHAR pWriteDataBuffer;

    DbgPrint("MyWrite\r\n");
    pIoStackIrp = IoGetCurrentIrpStackLocation(Irp);
    
    if(pIoStackIrp)
    {
        pWriteDataBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
    
        if(pWriteDataBuffer)
        {
           if(IsStringTerminated(pWriteDataBuffer, pIoStackIrp->Parameters.Write.Length))
           {
                DbgPrint(pWriteDataBuffer);
           }
        }
    }

    return NtStatus;
}

NTSTATUS MyCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyCreate Called \r\n");

    return NtStatus;
}

NTSTATUS MyClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyClose Called \r\n");

    return NtStatus;
}

NTSTATUS MyIoControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyIoControl Called \r\n");

    return NtStatus;
}

NTSTATUS MyRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyRead Called \r\n");

    return NtStatus;
}

int IsStringTerminated(PCHAR pString, unsigned int uiLength)
{
    int bStringIsTerminated = 0;
    unsigned int uiIndex = 0;

    while(uiIndex < uiLength && bStringIsTerminated == FALSE)
    {
        if(pString[uiIndex] == '\0')
        {
            bStringIsTerminated = 1;
        }
        else
        {
           uiIndex++;
        }
    }

    return bStringIsTerminated;
}

**Melem** · 26/02/2009, 19h56

Je n'ai pas encore le temps de tester mais je vais voir ça. Pourtant le code à l'air bon ...

Je posterai dès que j'aurai trouvé ce qui ne va pas.

A+.

**Prof** · 27/02/2009, 14h03

Bonjour.

Il me semble qu'à la fin de toutes les "MajorFunction", juste avant return NtStatus, il faut appeler IoCompleteRequest avec le pointeur sur l' IRP et un paramètre spécifiant l'augmentation éventuelle de priorité.
( en général, on laisse la priorité inchangée en passant IO_NO_INCREMENT )

Si cela n'est pas fait, en particulier par MyWrite, le gestionnaire d'E/S ne sait pas que la requête est achevée et l'IRP remplie ...

Serait-ce l'explication du problème rencontré ?

**Melem** · 27/02/2009, 18h53

Il manquait "juste" la ligne suivante, que l'on peut insérer après pDriverObject->DriverUnload = OnUnload; par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pDeviceObject->Flags |= DO_DIRECT_IO;

En effet, dans la fonction MyWrite, tu accèdes au Buffer comme si la communication se faisait en mode direct alors que le mode actuel est ni direct, ni bufferisé (parce que tu n'as pas touché à pDeviceObject->Flags ...). Chez moi, ça a causé une erreur fatale

. Si tu veux communiquer en mode direct, ajoute la ligne ci-dessus. Sinon bin y aura pas mal de chose à changer dans ta fonction MyWrite ...

@Prof : IoCompleteRequest n'est jamais obligatoire. En fait si, mais cette fonction sera toujours appelée, implicitement (par l'IO Manager au retour de l'IRP handler si ce dernier ne l'a pas appelée explicitement) ou explicitement. L'appel explicite permet de constituer soi-même les informations à retourner à l'IO Manager.

**Voldemort09** · 27/02/2009, 22h50

J'ai essayer mais rien a la sortie debug(voir screen). Ca a marché chez toi ?
(A la sortie debug). Je vais encore attendre une ou deux réponse et j'essaye une autre méthode de la direct.

**Melem** · 01/03/2009, 21h23

Je poste le code complet vu que le tiens comporte une erreur qui ne fait pas passer la compilation ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include "ntddk.h"

void OnUnload(IN PDRIVER_OBJECT DriverObject);

NTSTATUS MyIoControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyClose(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS MyRead(PDEVICE_OBJECT DeviceObject, PIRP Irp);

int IsStringTerminated(PCHAR pString, unsigned int uiLength);
void OnUnload(IN PDRIVER_OBJECT DriverObject);

int state;
NTSTATUS NtStatus = STATUS_SUCCESS;
PDEVICE_OBJECT pDeviceObject = NULL;
UNICODE_STRING usDriverName, usDosDeviceName;


NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING theRegistryPath)
{
	DbgPrint("I loaded!\n");
	
    RtlInitUnicodeString(&usDriverName, L"\\Device\\IRP_Communication");
    RtlInitUnicodeString(&usDosDeviceName, L"\\DosDevices\\IRP_Communication");
	NtStatus = IoCreateDevice(pDriverObject, 0, &usDriverName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDeviceObject);

	pDriverObject->MajorFunction[IRP_MJ_CLOSE]             = MyClose;
	pDriverObject->MajorFunction[IRP_MJ_CREATE]            = MyCreate;
	pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]    = MyIoControl;
	pDriverObject->MajorFunction[IRP_MJ_READ]              = MyRead;
	pDriverObject->MajorFunction[IRP_MJ_WRITE]             = MyWrite;
	IoCreateSymbolicLink(&usDosDeviceName, &usDriverName);
		
	pDriverObject->DriverUnload  = OnUnload;
	
	pDeviceObject->Flags |= DO_DIRECT_IO;
	
	return STATUS_SUCCESS;
}

void OnUnload(IN PDRIVER_OBJECT DriverObject)
{
	DbgPrint("OnUnload called\n");
}

NTSTATUS MyWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    PIO_STACK_LOCATION pIoStackIrp = NULL;
    PCHAR pWriteDataBuffer;

    DbgPrint("MyWrite\r\n");
    pIoStackIrp = IoGetCurrentIrpStackLocation(Irp);
    
    if(pIoStackIrp)
    {
        pWriteDataBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
    
        if(pWriteDataBuffer)
        {
           if(IsStringTerminated(pWriteDataBuffer, pIoStackIrp->Parameters.Write.Length))
           {
                DbgPrint(pWriteDataBuffer);
           }
        }
    }

    return NtStatus;
}

NTSTATUS MyCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyCreate Called \r\n");

    return NtStatus;
}

NTSTATUS MyClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyClose Called \r\n");

    return NtStatus;
}

NTSTATUS MyIoControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyIoControl Called \r\n");

    return NtStatus;
}

NTSTATUS MyRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DbgPrint("MyRead Called \r\n");

    return NtStatus;
}

int IsStringTerminated(PCHAR pString, unsigned int uiLength)
{
    int bStringIsTerminated = 0;
    unsigned int uiIndex = 0;

    while(uiIndex < uiLength && bStringIsTerminated == FALSE)
    {
        if(pString[uiIndex] == '\0')
        {
            bStringIsTerminated = 1;
        }
        else
        {
           uiIndex++;
        }
    }

    return bStringIsTerminated;
}

Rien à changer dans le programme utilisateur.

**Voldemort09** · 03/03/2009, 12h14

C'est bizarre, il n'y a rien a la sortie debug...
(J'ai essayé avec le code que tu m'a donné et le code du prog utilisateur que j'ai posté au dessus).
Et comme avant j'ai la confirmation que le dirver est chargé.

Lire/Ecrire dans un device depuis un driver[IRP]

Windows

Discussions similaires

Partager

Partager