En voici un en Delphi (bien que le parametre /install suffit en général comme le précise l'auteur) : http://groups.google.com/groups?selm?799d62%40newsgroups.borland.com&oe=UTF-8&output=gplain
Pascal exDK-feïné (j'ai enfin un nouveau portable de pauvre...)
"O. Thebault" <othebault@nospam.fr> wrote in message news:<brn114$dua$1@news-reader1.wanadoo.fr>...
Sur l'API CreateService on peut avoir un paramètre qui indique que le
service est un driver ou un système de fichier.
Ou peut on trouver des informations sur ce genre de service ? un exemple de
source ?
En voici un en Delphi (bien que le parametre /install suffit en
général comme le précise l'auteur) :
http://groups.google.com/groups?selm?799d62%40newsgroups.borland.com&oe=UTF-8&output=gplain
Pascal exDK-feïné (j'ai enfin un nouveau portable de pauvre...)
En voici un en Delphi (bien que le parametre /install suffit en général comme le précise l'auteur) : http://groups.google.com/groups?selm?799d62%40newsgroups.borland.com&oe=UTF-8&output=gplain
Pascal exDK-feïné (j'ai enfin un nouveau portable de pauvre...)
O. Thebault
Pour un service NT de type Win32, je suis tout à fait d'accord. On trouve plein d'exemples sur Google. Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API CreateService qui peut avoir comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER. Et à ce sujet on trouve beaucoup plus de questions que de réponse précise...
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose justement ce genre de service dans la propriété ServiceType de la classe TService pour produire un fichier de type exe.....En gros pour précisez ma question quel est la différence entre les services de type driver et les drivers tout court (style VxD). (en dehors du fait que l'un est au format PE et l'autre au format LE)
Si ce type de service existe effectivement, quels sont les API à utiliser ??? (en dehors de CreateService, SetServiceStatus, etc....)
"Pascal Chapuis" a écrit dans le message de news:
"O. Thebault" wrote in message
news:<brn114$dua$...
> Sur l'API CreateService on peut avoir un paramètre qui indique que le > service est un driver ou un système de fichier. > > Ou peut on trouver des informations sur ce genre de service ? un exemple
Pascal exDK-feïné (j'ai enfin un nouveau portable de pauvre...)
Pour un service NT de type Win32, je suis tout à fait d'accord. On trouve
plein d'exemples sur Google.
Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API
CreateService qui peut avoir
comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER.
Et à ce sujet on trouve beaucoup plus de questions que de réponse précise...
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose
justement ce genre
de service dans la propriété ServiceType de la classe TService pour produire
un fichier de type
exe.....En gros pour précisez ma question quel est la différence entre les
services de type driver et
les drivers tout court (style VxD). (en dehors du fait que l'un est au
format PE et l'autre au format LE)
Si ce type de service existe effectivement, quels sont les API à utiliser
??? (en dehors de CreateService,
SetServiceStatus, etc....)
"Pascal Chapuis" <Pascal.chapuis@online.fr> a écrit dans le message de news:
ccd96b70.0312161425.18638222@posting.google.com...
"O. Thebault" <othebault@nospam.fr> wrote in message
news:<brn114$dua$1@news-reader1.wanadoo.fr>...
> Sur l'API CreateService on peut avoir un paramètre qui indique que le
> service est un driver ou un système de fichier.
>
> Ou peut on trouver des informations sur ce genre de service ? un exemple
Pour un service NT de type Win32, je suis tout à fait d'accord. On trouve plein d'exemples sur Google. Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API CreateService qui peut avoir comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER. Et à ce sujet on trouve beaucoup plus de questions que de réponse précise...
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose justement ce genre de service dans la propriété ServiceType de la classe TService pour produire un fichier de type exe.....En gros pour précisez ma question quel est la différence entre les services de type driver et les drivers tout court (style VxD). (en dehors du fait que l'un est au format PE et l'autre au format LE)
Si ce type de service existe effectivement, quels sont les API à utiliser ??? (en dehors de CreateService, SetServiceStatus, etc....)
"Pascal Chapuis" a écrit dans le message de news:
"O. Thebault" wrote in message
news:<brn114$dua$...
> Sur l'API CreateService on peut avoir un paramètre qui indique que le > service est un driver ou un système de fichier. > > Ou peut on trouver des informations sur ce genre de service ? un exemple
Pascal exDK-feïné (j'ai enfin un nouveau portable de pauvre...)
adebaene
"O. Thebault" wrote in message news:<brp2d6$dmo$...
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose justement ce genre de service dans la propriété ServiceType de la classe TService pour produire un fichier de type exe.....
On ne peut pas faire de drivers avec autre chose que VC.
En gros pour précisez ma question quel est la différence entre les services de type driver et les drivers tout court (style VxD). (en dehors du fait que l'un est au format PE et l'autre au format LE)
Les VxD n'existent (existaient? on peut toujours rêver) que sous Windows 9x. Sous NT, les drivers sont des images PE "normales", et il se trouve qu'on peut les installer via la même API que les services (c'est le SCM qui se charge de choisir quels drivers charger au démarrage, avant de charger les services).
Au sein des drivers, les systèmes de fichiers sont un cas à part mais je ne saurais pas t'expliquer techniquement pourquoi (il faut un kit séparé, l'Installable File System - IFS - pour les développer).
Si ce type de service existe effectivement, quels sont les API à utiliser ??? (en dehors de CreateService, SetServiceStatus, etc....)
cf le DDK.
Arnaud
"O. Thebault" <othebault@nospam.fr> wrote in message news:<brp2d6$dmo$2@news-reader4.wanadoo.fr>...
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose
justement ce genre
de service dans la propriété ServiceType de la classe TService pour produire
un fichier de type
exe.....
On ne peut pas faire de drivers avec autre chose que VC.
En gros pour précisez ma question quel est la différence entre les
services de type driver et
les drivers tout court (style VxD). (en dehors du fait que l'un est au
format PE et l'autre au format LE)
Les VxD n'existent (existaient? on peut toujours rêver) que sous
Windows 9x. Sous NT, les drivers sont des images PE "normales", et il
se trouve qu'on peut les installer via la même API que les services
(c'est le SCM qui se charge de choisir quels drivers charger au
démarrage, avant de charger les services).
Au sein des drivers, les systèmes de fichiers sont un cas à part mais
je ne saurais pas t'expliquer techniquement pourquoi (il faut un kit
séparé, l'Installable File System - IFS - pour les développer).
Si ce type de service existe effectivement, quels sont les API à utiliser
??? (en dehors de CreateService,
SetServiceStatus, etc....)
"O. Thebault" wrote in message news:<brp2d6$dmo$...
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose justement ce genre de service dans la propriété ServiceType de la classe TService pour produire un fichier de type exe.....
On ne peut pas faire de drivers avec autre chose que VC.
En gros pour précisez ma question quel est la différence entre les services de type driver et les drivers tout court (style VxD). (en dehors du fait que l'un est au format PE et l'autre au format LE)
Les VxD n'existent (existaient? on peut toujours rêver) que sous Windows 9x. Sous NT, les drivers sont des images PE "normales", et il se trouve qu'on peut les installer via la même API que les services (c'est le SCM qui se charge de choisir quels drivers charger au démarrage, avant de charger les services).
Au sein des drivers, les systèmes de fichiers sont un cas à part mais je ne saurais pas t'expliquer techniquement pourquoi (il faut un kit séparé, l'Installable File System - IFS - pour les développer).
Si ce type de service existe effectivement, quels sont les API à utiliser ??? (en dehors de CreateService, SetServiceStatus, etc....)
cf le DDK.
Arnaud
O. Thebault
> On ne peut pas faire de drivers avec autre chose que VC.
Si sous NT un driver est un service dans un fichier "PE", rien n'interdit d'en programmer avec Delphi, non ?
> On ne peut pas faire de drivers avec autre chose que VC.
Si sous NT un driver est un service dans un fichier "PE", rien
n'interdit d'en programmer avec Delphi, non ?
> On ne peut pas faire de drivers avec autre chose que VC.
Si sous NT un driver est un service dans un fichier "PE", rien n'interdit d'en programmer avec Delphi, non ?
Pascal.chapuis
"O. Thebault" wrote in message news:<brp2d6$dmo$...
Pour un service NT de type Win32, je suis tout à fait d'accord. On trouve plein d'exemples sur Google. Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API CreateService qui peut avoir comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER. Et à ce sujet on trouve beaucoup plus de questions que de réponse précise...
Ces parametres sont pour des "Windows base services" soit win32. Avec "CreateService Driver .vxd OR .sys" sur Google il y a quelques exemples.
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose justement ce genre de service dans la propriété ServiceType de la classe TService pour produire un fichier de type exe.....
lpServiceStartName :
If the service type is SERVICE_KERNEL_DRIVER or SERVICE_FILE_SYSTEM_DRIVER, the name is the driver object name that the system uses to load the device driver. Specify NULL if the driver is to use a default object name created by the I/O system.
Dans ce cas le service n'est pas un driver mais plutot un pointeur vers "the driver object name". Il n'y a donc pas de probleme de structure entre le service (exe) implémenté via la classe TService et le driver qu'il désigne.
En gros pour précisez ma question quel est la différence entre les services de type driver et les drivers tout court (style VxD). (en dehors du fait que l'un est au format PE et l'autre au format LE)
Si ce type de service existe effectivement, quels sont les API à utiliser ??? (en dehors de CreateService, SetServiceStatus, etc....)
Pascal
"Veille techno ne veut pas dire Rave Party." (P. Chapuis)
"O. Thebault" <othebault@nospam.fr> wrote in message news:<brp2d6$dmo$2@news-reader4.wanadoo.fr>...
Pour un service NT de type Win32, je suis tout à fait d'accord. On trouve
plein d'exemples sur Google.
Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API
CreateService qui peut avoir
comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER.
Et à ce sujet on trouve beaucoup plus de questions que de réponse précise...
Ces parametres sont pour des "Windows base services" soit win32. Avec
"CreateService Driver .vxd OR .sys" sur Google il y a quelques
exemples.
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose
justement ce genre
de service dans la propriété ServiceType de la classe TService pour produire
un fichier de type
exe.....
lpServiceStartName :
If the service type is SERVICE_KERNEL_DRIVER or
SERVICE_FILE_SYSTEM_DRIVER, the name is the driver object name that
the system uses to load the device driver. Specify NULL if the driver
is to use a default object name created by the I/O system.
Dans ce cas le service n'est pas un driver mais plutot un pointeur
vers "the driver object name". Il n'y a donc pas de probleme de
structure entre le service (exe) implémenté via la classe TService et
le driver qu'il désigne.
En gros pour précisez ma question quel est la différence entre les
services de type driver et
les drivers tout court (style VxD). (en dehors du fait que l'un est au
format PE et l'autre au format LE)
Si ce type de service existe effectivement, quels sont les API à utiliser
??? (en dehors de CreateService,
SetServiceStatus, etc....)
Pascal
"Veille techno ne veut pas dire Rave Party." (P. Chapuis)
"O. Thebault" wrote in message news:<brp2d6$dmo$...
Pour un service NT de type Win32, je suis tout à fait d'accord. On trouve plein d'exemples sur Google. Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API CreateService qui peut avoir comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER. Et à ce sujet on trouve beaucoup plus de questions que de réponse précise...
Ces parametres sont pour des "Windows base services" soit win32. Avec "CreateService Driver .vxd OR .sys" sur Google il y a quelques exemples.
D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi propose justement ce genre de service dans la propriété ServiceType de la classe TService pour produire un fichier de type exe.....
lpServiceStartName :
If the service type is SERVICE_KERNEL_DRIVER or SERVICE_FILE_SYSTEM_DRIVER, the name is the driver object name that the system uses to load the device driver. Specify NULL if the driver is to use a default object name created by the I/O system.
Dans ce cas le service n'est pas un driver mais plutot un pointeur vers "the driver object name". Il n'y a donc pas de probleme de structure entre le service (exe) implémenté via la classe TService et le driver qu'il désigne.
En gros pour précisez ma question quel est la différence entre les services de type driver et les drivers tout court (style VxD). (en dehors du fait que l'un est au format PE et l'autre au format LE)
Si ce type de service existe effectivement, quels sont les API à utiliser ??? (en dehors de CreateService, SetServiceStatus, etc....)
Pascal
"Veille techno ne veut pas dire Rave Party." (P. Chapuis)
O. Thebault
Merci, très interressant....je vais me coucher moins bête ce soir.....
"Pascal Chapuis" a écrit dans le message de news:
"O. Thebault" wrote in message
news:<brp2d6$dmo$...
> Pour un service NT de type Win32, je suis tout à fait d'accord. On
trouve
> plein d'exemples sur Google. > Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API > CreateService qui peut avoir > comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER. > Et à ce sujet on trouve beaucoup plus de questions que de réponse
précise...
Ces parametres sont pour des "Windows base services" soit win32. Avec "CreateService Driver .vxd OR .sys" sur Google il y a quelques exemples.
> D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi
propose
> justement ce genre > de service dans la propriété ServiceType de la classe TService pour
produire
> un fichier de type > exe.....
lpServiceStartName :
If the service type is SERVICE_KERNEL_DRIVER or SERVICE_FILE_SYSTEM_DRIVER, the name is the driver object name that the system uses to load the device driver. Specify NULL if the driver is to use a default object name created by the I/O system.
Dans ce cas le service n'est pas un driver mais plutot un pointeur vers "the driver object name". Il n'y a donc pas de probleme de structure entre le service (exe) implémenté via la classe TService et le driver qu'il désigne.
>En gros pour précisez ma question quel est la différence entre les > services de type driver et > les drivers tout court (style VxD). (en dehors du fait que l'un est au > format PE et l'autre au format LE) > > Si ce type de service existe effectivement, quels sont les API à
utiliser
> ??? (en dehors de CreateService, > SetServiceStatus, etc....)
Pascal
"Veille techno ne veut pas dire Rave Party." (P. Chapuis)
Merci, très interressant....je vais me coucher moins bête ce soir.....
"Pascal Chapuis" <Pascal.chapuis@online.fr> a écrit dans le message de news:
ccd96b70.0312170628.4a0b35ce@posting.google.com...
"O. Thebault" <othebault@nospam.fr> wrote in message
news:<brp2d6$dmo$2@news-reader4.wanadoo.fr>...
> Pour un service NT de type Win32, je suis tout à fait d'accord. On
trouve
> plein d'exemples sur Google.
> Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API
> CreateService qui peut avoir
> comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER.
> Et à ce sujet on trouve beaucoup plus de questions que de réponse
précise...
Ces parametres sont pour des "Windows base services" soit win32. Avec
"CreateService Driver .vxd OR .sys" sur Google il y a quelques
exemples.
> D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi
propose
> justement ce genre
> de service dans la propriété ServiceType de la classe TService pour
produire
> un fichier de type
> exe.....
lpServiceStartName :
If the service type is SERVICE_KERNEL_DRIVER or
SERVICE_FILE_SYSTEM_DRIVER, the name is the driver object name that
the system uses to load the device driver. Specify NULL if the driver
is to use a default object name created by the I/O system.
Dans ce cas le service n'est pas un driver mais plutot un pointeur
vers "the driver object name". Il n'y a donc pas de probleme de
structure entre le service (exe) implémenté via la classe TService et
le driver qu'il désigne.
>En gros pour précisez ma question quel est la différence entre les
> services de type driver et
> les drivers tout court (style VxD). (en dehors du fait que l'un est au
> format PE et l'autre au format LE)
>
> Si ce type de service existe effectivement, quels sont les API à
utiliser
> ??? (en dehors de CreateService,
> SetServiceStatus, etc....)
Pascal
"Veille techno ne veut pas dire Rave Party." (P. Chapuis)
Merci, très interressant....je vais me coucher moins bête ce soir.....
"Pascal Chapuis" a écrit dans le message de news:
"O. Thebault" wrote in message
news:<brp2d6$dmo$...
> Pour un service NT de type Win32, je suis tout à fait d'accord. On
trouve
> plein d'exemples sur Google. > Par contre, ce qui m'intrigue c'est le paramètre dwServiceType de l'API > CreateService qui peut avoir > comme valeur SERVICE_FILE_SYSTEM_DRIVER ou SERVICE_KERNEL_DRIVER. > Et à ce sujet on trouve beaucoup plus de questions que de réponse
précise...
Ces parametres sont pour des "Windows base services" soit win32. Avec "CreateService Driver .vxd OR .sys" sur Google il y a quelques exemples.
> D'après mes quelques souvenirs du DDK, je trouve étrange que Delphi
propose
> justement ce genre > de service dans la propriété ServiceType de la classe TService pour
produire
> un fichier de type > exe.....
lpServiceStartName :
If the service type is SERVICE_KERNEL_DRIVER or SERVICE_FILE_SYSTEM_DRIVER, the name is the driver object name that the system uses to load the device driver. Specify NULL if the driver is to use a default object name created by the I/O system.
Dans ce cas le service n'est pas un driver mais plutot un pointeur vers "the driver object name". Il n'y a donc pas de probleme de structure entre le service (exe) implémenté via la classe TService et le driver qu'il désigne.
>En gros pour précisez ma question quel est la différence entre les > services de type driver et > les drivers tout court (style VxD). (en dehors du fait que l'un est au > format PE et l'autre au format LE) > > Si ce type de service existe effectivement, quels sont les API à
utiliser
> ??? (en dehors de CreateService, > SetServiceStatus, etc....)
Pascal
"Veille techno ne veut pas dire Rave Party." (P. Chapuis)
Arnaud Debaene
O. Thebault wrote:
On ne peut pas faire de drivers avec autre chose que VC.
Si sous NT un driver est un service dans un fichier "PE", rien n'interdit d'en programmer avec Delphi, non ?
Non, car en mode noyau, tu ne disposes pas des runtimes de tous les langages de haut-niveau. Par ailleurs, pour écrire un driver il faut être capable de manipuler un certain nombre d'éléments (placer ds fonctions en mémoires "pageable" ou pas, gérer les structured exception handling, ....) qui sont de spécificités MS et ne sont à priori disponibles qu'avec VC.
Arnaud
O. Thebault wrote:
On ne peut pas faire de drivers avec autre chose que VC.
Si sous NT un driver est un service dans un fichier "PE", rien
n'interdit d'en programmer avec Delphi, non ?
Non, car en mode noyau, tu ne disposes pas des runtimes de tous les langages
de haut-niveau.
Par ailleurs, pour écrire un driver il faut être capable de manipuler un
certain nombre d'éléments (placer ds fonctions en mémoires "pageable" ou
pas, gérer les structured exception handling, ....) qui sont de spécificités
MS et ne sont à priori disponibles qu'avec VC.
On ne peut pas faire de drivers avec autre chose que VC.
Si sous NT un driver est un service dans un fichier "PE", rien n'interdit d'en programmer avec Delphi, non ?
Non, car en mode noyau, tu ne disposes pas des runtimes de tous les langages de haut-niveau. Par ailleurs, pour écrire un driver il faut être capable de manipuler un certain nombre d'éléments (placer ds fonctions en mémoires "pageable" ou pas, gérer les structured exception handling, ....) qui sont de spécificités MS et ne sont à priori disponibles qu'avec VC.
Arnaud
Gils Gayraud
> Si sous NT un driver est un service
Bon on va dire que ce n'est pas vrai. :-) Un service sous NT n'est qu'un excutable qui s'execute en mode User (ring 3) mais sans pouvoir avoir le droit de s'exprimer a travers un ecran console ou fenetre Windows.
Mainenant on peut lancer un driver de la même maniere qu'une service enligne de commande a l'aide de net start et c'est une driver et non pas un service.
La principale différence entre un service et un driver, le service s'excute en mode applicatif et ne peut pas acceder directement au materiel contrairement au driver qui s'execute en mode kernel et qui grace a cela a les droit d'acceder au materiel quand celui-ci est libre d'accès et pas verouiller par un autre driver precedemment lancer.
Maintenant si je peix me permettre on peut developper du driver ou du service dans n'importe quel langage, a deux conditions, que ce langage sache generer du code machine comprehensible par l'OS soit en ring 3 soit en ring 0, mode user ou mode kernel, et la deuxieme condition d'avoir le wrapper pour faire l'association entre le langage et les routines documentées dans le DDK pour attaquer le Kernel de NT a 2003.
Ces wrappers existent et sont souvent disponible chez des societes ou partenaires de MS tiers partie.
Les wrappers pour le C/C++ de MS sont realisé pas MS mais Watcom avec sont C/C++ ont aussi developpé des wrappers.
Pour Delphi, je ne sais pas si cela existe mais cela ne m'étonnerait pas. Il faut peut-être posé la question du coté des developpeurs de Indy groupe très serieux et competent du coté developpement noyau.
-- Cordialement GG.
> Si sous NT un driver est un service
Bon on va dire que ce n'est pas vrai. :-)
Un service sous NT n'est qu'un excutable qui s'execute
en mode User (ring 3) mais sans pouvoir avoir le droit
de s'exprimer a travers un ecran console ou fenetre
Windows.
Mainenant on peut lancer un driver de la même maniere
qu'une service enligne de commande a l'aide de net start
et c'est une driver et non pas un service.
La principale différence entre un service et un driver, le
service s'excute en mode applicatif et ne peut pas acceder
directement au materiel contrairement au driver qui s'execute
en mode kernel et qui grace a cela a les droit d'acceder au
materiel quand celui-ci est libre d'accès et pas verouiller
par un autre driver precedemment lancer.
Maintenant si je peix me permettre on peut developper du
driver ou du service dans n'importe quel langage, a deux
conditions, que ce langage sache generer du code machine
comprehensible par l'OS soit en ring 3 soit en ring 0, mode
user ou mode kernel, et la deuxieme condition d'avoir le
wrapper pour faire l'association entre le langage et les
routines documentées dans le DDK pour attaquer le Kernel
de NT a 2003.
Ces wrappers existent et sont souvent disponible chez
des societes ou partenaires de MS tiers partie.
Les wrappers pour le C/C++ de MS sont realisé pas
MS mais Watcom avec sont C/C++ ont aussi developpé
des wrappers.
Pour Delphi, je ne sais pas si cela existe mais cela ne
m'étonnerait pas. Il faut peut-être posé la question du
coté des developpeurs de Indy groupe très serieux et
competent du coté developpement noyau.
Bon on va dire que ce n'est pas vrai. :-) Un service sous NT n'est qu'un excutable qui s'execute en mode User (ring 3) mais sans pouvoir avoir le droit de s'exprimer a travers un ecran console ou fenetre Windows.
Mainenant on peut lancer un driver de la même maniere qu'une service enligne de commande a l'aide de net start et c'est une driver et non pas un service.
La principale différence entre un service et un driver, le service s'excute en mode applicatif et ne peut pas acceder directement au materiel contrairement au driver qui s'execute en mode kernel et qui grace a cela a les droit d'acceder au materiel quand celui-ci est libre d'accès et pas verouiller par un autre driver precedemment lancer.
Maintenant si je peix me permettre on peut developper du driver ou du service dans n'importe quel langage, a deux conditions, que ce langage sache generer du code machine comprehensible par l'OS soit en ring 3 soit en ring 0, mode user ou mode kernel, et la deuxieme condition d'avoir le wrapper pour faire l'association entre le langage et les routines documentées dans le DDK pour attaquer le Kernel de NT a 2003.
Ces wrappers existent et sont souvent disponible chez des societes ou partenaires de MS tiers partie.
Les wrappers pour le C/C++ de MS sont realisé pas MS mais Watcom avec sont C/C++ ont aussi developpé des wrappers.
Pour Delphi, je ne sais pas si cela existe mais cela ne m'étonnerait pas. Il faut peut-être posé la question du coté des developpeurs de Indy groupe très serieux et competent du coté developpement noyau.
