IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

API, COM et SDKs Delphi Discussion :

SPTI - Détection des lecteurs cd - Lettres de lecteurs


Sujet :

API, COM et SDKs Delphi

  1. #1
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut SPTI - Détection des lecteurs cd - Lettres de lecteurs
    Bonjour,

    Depuis quelque temps, je travaille sur un moteur d'accès aux périphréiques cd\dvd.
    Mon projet est fonctionnel, et le programme final (freeware) dispo sur le net depuis quelques semaines déjà : http://www.allfirmwares.com/downloads/onlinedetect.exe (version fonctionnelle)
    http://www.allfirmwares.com/temp/onlinedetect.exe (version actuelle, avec infos de debug)


    Ce moteur utilise les fonctions aspi de base pour w9x, et le SPTI pour les sytèmes W2k/XP/2k3.

    La manière de scanner les périphériques, de manière standard, est de récupérer la liste des lecteurs (C à Z) et de tester s'ils sont utilisés et de types CD.
    Or certaines personnes ont retiré la letter de lecteur de leur périphérique.
    J'ai donc un périphérique de branché, mais inacessible par un utilisateur standard.


    Pour cette raison je demande au système de me fournir la liste des lecteurs cd (cf code ci-dessous).

    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
     
    Procedure TDriverInterfaceSPTI.GetUnitsFromClassDevices;
    {--------------------------------------------
      Scanne la classe CD-Rom
      ****
      Sources :
      http://msdn.microsoft.com/library/en-us/devio/base/setupdigetclassdevs.asp
    ---------------------------------------------}
    const
      FuncName : string = 'TDriverInterfaceSPTI.GetUnitsFromClassDevices';
    var
      DevList : HDEVINFO;                           // Liste des périphériques de type CD
      DevI : Integer;                               // compteur, pour le Ieme périph de la liste
      Success : Boolean;
      DeviceInterfaceData: TSPDeviceInterfaceData;
      DevData: TSPDevInfoData;
      BytesReturned: DWORD;
      FunctionClassDeviceData: PSPDeviceInterfaceDetailData;
      aUnit : TUnitSPTI;
    Begin
      Self.DebugAddMsg(FuncName, '');
     
      Self.Units.Clear;                                                             // Efface la liste des lecteurs
     
      { récupère la liste des périph CD }
      DevList := SetupDiGetClassDevs(@CDROMCLASSGUID, nil, 0, DIGCF_PRESENT or DIGCF_INTERFACEDEVICE);
      if (DevList = Pointer(INVALID_HANDLE_VALUE)) then Begin
        Self.DebugAddMsg(FuncName, 'Impossible d''obtenir le handle sur la liste des cd');
        Exit;
      End;
     
      { information sur un périphérique de la liste }
      DevI := 0;
      Repeat
        DeviceInterfaceData.cbSize := SizeOf(TSPDeviceInterfaceData);
        Success := SetupDiEnumDeviceInterfaces(DevList, nil, CDROMCLASSGUID, DevI, DeviceInterfaceData);
        if Success then begin
          DevData.cbSize := SizeOf(DevData);
          BytesReturned := 0;
          SetupDiGetDeviceInterfaceDetail(DevList, @DeviceInterfaceData, nil, 0, BytesReturned, @DevData);
          if (BytesReturned <> 0) and (GetLastError = ERROR_INSUFFICIENT_BUFFER) then begin
            FunctionClassDeviceData := AllocMem(BytesReturned);
            FunctionClassDeviceData.cbSize := 5;
            if SetupDiGetDeviceInterfaceDetail(DevList, @DeviceInterfaceData, FunctionClassDeviceData, BytesReturned, BytesReturned, @DevData) then Begin
              MessageBox(0, PChar(@FunctionClassDeviceData.DevicePath), '', MB_OK);
              aUnit := TUnitSPTI.Create(Self, PChar(@FunctionClassDeviceData.DevicePath));
              Self.Units.Add(aUnit);
            End;
          End;
          Inc(DevI,1);
        End;
      Until not Success;
    End;
    j'obtiens sur cette procedure de tests, le message suivant :



    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    \\?\ide#cdrommatshita_ujda720_dvd#cdrw_______________1.00____#5&306ef82c&0&0.0.0#{53f56308-b6bf-11d0-94f2-00a0c91efb8b}
    Je souhaiterais maintenant pouvoir dire quelle est la lettre de lecteur associée au lien ci-dessus.
    Je sais juste que les lettres de lecteurs et périphériques "montés" sont gérés ici :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices
    Si quelqu'un sait comment passer du lien à la lettre de lecteur....


    Tant que j'y suis, est ce que quelqu'un sait comment obtenir les informations suivantes : si le lecteur est connecté sur le primary\secondary ide, en master\slave.


    Merci d'avance, et s'il y a un spécialiste SCSI\SPTI\ASPI sur le forum et qu'il veuille bien jetter un oeil de temps à autre à mon projet, voir me donner un coup de main plus poussé, je lui en serait très reconnaissant.


    Merci d'avance pour votre aide.

  2. #2
    Membre chevronné
    Avatar de Pierre Castelain
    Inscrit en
    Avril 2002
    Messages
    523
    Détails du profil
    Informations forums :
    Inscription : Avril 2002
    Messages : 523
    Points : 1 943
    Points
    1 943
    Par défaut
    Ce que je vais écrire maintenant n'est qu'une déduction. Je ne connais pas du tout cette fonction et les structures qui sont utilisées.
    Par contre, je sais reconnaître un GUID quand j'en vois un. Et il y a en a un à la fin de la chaine retournée :
    \\?\ide#cdrommatshita_ujda720_dvd#cdrw_______________1.00____#5&306ef82c&0&0.0.0#{53f56308-b6bf-11d0-94f2-00a0c91efb8b}
    Quand je regarde le contenu de HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices, je vois que sont listés les périphériques "montés". Ceux-ci sont affichés sous deux formes. La première contient le GUID en question et la seconde la lettre de lecteur associée. En regardant plus en détail, il semblerait que l'on puisse détecter les "couples" de clés en comparant leur valeur respective.
    Je dirais donc que tu dois pouvoir faire ceci :
    - Extraire le guid de la chaîne que tu reçois (un guid a une longueur fixe).
    - Rechercher la clé contenant ce guid dans HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices et lire la valeur de cette clé.
    - Rechercher parmis les clés "\DosDevice\?" celle dont la valeur est égale à celle que tu viens de lire.
    - Si tu en trouve une (ce qui n'est pas sûr), il ne reste plus qu'à récupérer la lettre de lecteur.

    Je le répète, ceci est juste une déduction. Je n'ai même pas vérifié, mais cela me parait logique.

  3. #3
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut
    Bonjour,

    Si c'était si simple.... je pense que je n'aurais pas posé la question
    mais merci d'essayer de m'aider. cela fait plaisir de voir que mon sujet peut intéresser


    Comme tu l'as vu, ma valeur possède une GUID, reconnaissable.
    mais celle-ci ne fait pas référence (sur mes systèmes du moins) à un lecteur CD, mais à une classe de gestion des cd.

    dans la section HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices, j'ai comme tu le fais remarquer :
    - la liste des points de montages (\??\Volume{GUID}), et un code
    - dosdevices, et un code.

    je peux donc retrouver par ce biais la, les points de montages associés aux dosdevices. (lien sympolique mappé sur une lettre de lecteur).
    j'avais pensé utiliser la fonction QueryDosdevices à un moment... mais j'ai pas trouvé ce que je voulais... cete fonction me permet de retrouver pour une lettre, un point de montage.

    or, je ne sais pas comment passer de mon point de montage \\?\ide#... à une référence \??\Volume{GUID}


    je crains de devoir trouver une autre méthode pour retrouver les lettres de lecteurs associées

  4. #4
    Membre confirmé
    Avatar de lil_jam63
    Profil pro
    Inscrit en
    Janvier 2004
    Messages
    447
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2004
    Messages : 447
    Points : 600
    Points
    600
    Par défaut
    Bonjour, je m'étais un peu interessé a cette couche ASPI/SPTI passé un moment, je pense que j'ai ce qu'il te faut, c'est une petite collection d'unités que j'ai récupéré au fur et à mesure de mes recherches. J'ai regardé rapidement suite à ton post et il me semble qu'ils passent par la base de registre.

    Lien
    ----------------------------------------------------
    Avant de poster, pensez à utiliser les différents outils à votre disposition:
    Google, la FAQ et le moteur de recherche.

  5. #5
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut
    @lil_jam63
    Merci beaucoup pour tes unités.
    si je les avais eu il y a quelques mois... ca m'aurait évité bien du travail

    disons que je travaille sur une sorte de wnaspi32.dll avec compatibilité win9x,2K\xp\2k3... et qu ele temps passant, j'approfondis mon étude des drivers....
    mais étudiant, sans personne pour me cadrer, ou me tuyauter, il est relativement difficile d'avancer sur ce domaine, très pointu.


    encore une fois merci beaucoup.
    je vais étudier tes codes en détail

  6. #6
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut
    un seul problème cependant....
    il y a un appel à la fonction "GetLogicalDriveStrings".

    cela revient à faire un scan des lecteurs A à Z, tester si le lecteur est de type cd, puis récupérer les infos.

    or si j'ai un lecteur "caché", qui ne comporte pas de lettre de lecteur... je ne vais pas pouvoir le détecter par cette méthode.
    c'ets pour ce problème, que je fais appel à des spécialistes...

    j'essaye de demander à windows qu'il me retourne la liste complète de ces cd....


    une autre solution, pourrait consister à scanner les plages SCSI%d ou CDRom%d avec un CreateFile...et obtenir ou non un handle.
    mais je ne sais pas si c'est propre... et je ne suis pas un habitué des handles...

  7. #7
    Membre chevronné
    Avatar de Pierre Castelain
    Inscrit en
    Avril 2002
    Messages
    523
    Détails du profil
    Informations forums :
    Inscription : Avril 2002
    Messages : 523
    Points : 1 943
    Points
    1 943
    Par défaut
    Bon, désolé d'avoir répondu à coté, mais j'avais prévenu

    Tu pourrais monter un petit source de qui utilise la fonction pour qu'on puisse tester ?

  8. #8
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut
    je te fournirais la source complémentaire à la première de mon sujet, de manière à ce que tu puisses compiler le tout.

    Pour le moteur en lui même, je suis presque, en train de réécrire une aspi au final... mais pour 2k/xp
    sous w9x, je e sais rien faire, si ce n'est m'appuyer sur une aspi existante

    le mieux serait de coder un driver pur....
    mais je n'ai ni le niveau, ni envisage une réelle utilité.

    une fois le projet fini, il sera diffusé en freeware.
    quand à l'accès complet aux sources... (moteur dos, linux, win 9x, 2k/xp/2k3) tout dépendra de si j'arrive à monter une équipe et de la motivation.

    merci pour l'aide, et pour les codes (dont j'en avaisq deja un certain nombre)

  9. #9
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut
    je travaille sur cette portion de code, depuis qq jours :

    le code source est disponible chez Microsoft :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    http://support.microsoft.com/default.aspx?scid=kb;EN-US;Q305184
    je me suis basé sur le code JvHidControllerClass.pas aussi.

    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
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
     
    Type
      HDEVINFO = Pointer; {$EXTERNALSYM HDEVINFO}
      ULONG_PTR = DWORD;  {$EXTERNALSYM ULONG_PTR}
      PCSTR = LPCSTR;
     
    const  
      GUID_DEVCLASS_CDROM : TGUID = '{4D36E965-E325-11CE-BFC1-08002BE10318}';
      CDROMCLASSGUID      : TGUID = '{53f56308-b6bf-11d0-94f2-00a0c91efb8b}';
     
    const
      { Flags controlling what is included in the device information set built by SetupDiGetClassDevs }
      DIGCF_DEFAULT         = $00000001;{$EXTERNALSYM DIGCF_DEFAULT} // only valid with DIGCF_DEVICEINTERFACE
      DIGCF_PRESENT         = $00000002;{$EXTERNALSYM DIGCF_PRESENT}
      DIGCF_ALLCLASSES      = $00000004;{$EXTERNALSYM DIGCF_ALLCLASSES}
      DIGCF_PROFILE         = $00000008;{$EXTERNALSYM DIGCF_PROFILE}
      DIGCF_DEVICEINTERFACE = $00000010;{$EXTERNALSYM DIGCF_DEVICEINTERFACE}
      DIGCF_INTERFACEDEVICE = DIGCF_DEVICEINTERFACE;
     
    Type
      { Device information structure (references a device instance that is a member of a device information set }
      PSPDevInfoData = ^SP_DEVINFO_DATA;
      SP_DEVINFO_DATA = packed record
        cbSize: DWORD;
        ClassGuid: TGUID;
        DevInst: DWORD; // DEVINST handle
        Reserved: ULONG_PTR;
      end;
      {$EXTERNALSYM SP_DEVINFO_DATA}
      TSPDevInfoData = SP_DEVINFO_DATA;
     
     
     
      PSPDeviceInterfaceData = ^SP_DEVICE_INTERFACE_DATA;
      SP_DEVICE_INTERFACE_DATA = packed record
        cbSize: DWORD;
        InterfaceClassGuid: TGUID;
        Flags: DWORD;
        Reserved: ULONG_PTR;
      end;
      {$EXTERNALSYM SP_DEVICE_INTERFACE_DATA}
      TSPDeviceInterfaceData = SP_DEVICE_INTERFACE_DATA;
     
      PSPDeviceInterfaceDetailData = ^SP_DEVICE_INTERFACE_DETAIL_DATA;
      SP_DEVICE_INTERFACE_DETAIL_DATA = packed record
        cbSize: DWORD;
        DevicePath: array [0..0] of AnsiChar;
      end;
     
     
     
      function SetupDiGetClassDevs(const ClassGuid:PGUID; Enumerator: PCSTR; hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall; external 'Setupapi.dll' name 'SetupDiGetClassDevsA';
      {$EXTERNALSYM SetupDiGetClassDevs}
     
      function SetupDiEnumDeviceInfo(DeviceInfoSet: HDEVINFO; MemberIndex: DWORD; var DeviceInfoData: TSPDevInfoData): LongBool; stdcall; external 'Setupapi.dll';
      {$EXTERNALSYM SetupDiEnumDeviceInfo}
     
      function SetupDiGetDeviceRegistryProperty(DeviceInfoSet:HDEVINFO; DeviceInfoData: TSPDevInfoData; Property_: DWORD;
                                                var PropertyRegDataType: DWORD; PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
                                                var RequiredSize: DWORD): LongBool; stdcall; external 'Setupapi.dll' name 'SetupDiGetDeviceRegistryPropertyA';
      {$EXTERNALSYM SetupDiGetDeviceRegistryProperty}
     
     
      function SetupDiEnumDeviceInterfaces(DeviceInfoSet: HDEVINFO;
                                            DeviceInfoData: PSPDevInfoData; const InterfaceClassGuid: TGUID;
                                            MemberIndex: DWORD; var DeviceInterfaceData: TSPDeviceInterfaceData): LongBool; stdcall; external 'Setupapi.dll';
      {$EXTERNALSYM SetupDiEnumDeviceInterfaces}
     
     
      function SetupDiGetDeviceInterfaceDetail(DeviceInfoSet: HDEVINFO;
      DeviceInterfaceData: PSPDeviceInterfaceData;
      DeviceInterfaceDetailData: PSPDeviceInterfaceDetailData;
      DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
      Device: PSPDevInfoData): LongBool; stdcall; external 'Setupapi.dll' name 'SetupDiGetDeviceInterfaceDetailA';
     
     
    const
      SCSI_IOCTL_DATA_OUT            = 0;
      SCSI_IOCTL_DATA_IN             = 1;
      SCSI_IOCTL_DATA_UNSPECIFIED    = 2;
     
    // Standard IOCTL codes
      IOCTL_CDROM_READ_TOC = $24000;
      IOCTL_CDROM_GET_LAST_SESSION = $24038;
      IOCTL_SCSI_PASS_THROUGH = $4D004;
      IOCTL_SCSI_MINIPORT = $4D008;
      IOCTL_SCSI_GET_INQUIRY_DATA = $4100C;
      IOCTL_SCSI_GET_CAPABILITIES = $41010;
      IOCTL_SCSI_PASS_THROUGH_DIRECT = $4D014;
      IOCTL_SCSI_GET_ADDRESS = $41018;
     
     
     
    //
    // Device registry property codes
    // (Codes marked as read-only (R) may only be used for
    // SetupDiGetDeviceRegistryProperty)
    //
    // These values should cover the same set of registry properties
    // as defined by the CM_DRP codes in cfgmgr32.h.
    //
    // Note that SPDRP codes are zero based while CM_DRP codes are one based!
    //
    const
      SPDRP_DEVICEDESC                  = $00000000; {$EXTERNALSYM SPDRP_DEVICEDESC} // DeviceDesc (R/W)
      SPDRP_HARDWAREID                  = $00000001; {$EXTERNALSYM SPDRP_HARDWAREID} // HardwareID (R/W)
      SPDRP_COMPATIBLEIDS               = $00000002; {$EXTERNALSYM SPDRP_COMPATIBLEIDS} // CompatibleIDs (R/W)
      SPDRP_UNUSED0                     = $00000003; {$EXTERNALSYM SPDRP_UNUSED0} // unused
      SPDRP_SERVICE                     = $00000004; {$EXTERNALSYM SPDRP_SERVICE} // Service (R/W)
      SPDRP_UNUSED1                     = $00000005; {$EXTERNALSYM SPDRP_UNUSED1} // unused
      SPDRP_UNUSED2                     = $00000006; {$EXTERNALSYM SPDRP_UNUSED2} // unused
      SPDRP_CLASS                       = $00000007; {$EXTERNALSYM SPDRP_CLASS} // Class (R--tied to ClassGUID)
      SPDRP_CLASSGUID                   = $00000008; {$EXTERNALSYM SPDRP_CLASSGUID} // ClassGUID (R/W)
      SPDRP_DRIVER                      = $00000009; {$EXTERNALSYM SPDRP_DRIVER} // Driver (R/W)
      SPDRP_CONFIGFLAGS                 = $0000000A; {$EXTERNALSYM SPDRP_CONFIGFLAGS} // ConfigFlags (R/W)
      SPDRP_MFG                         = $0000000B; {$EXTERNALSYM SPDRP_MFG} // Mfg (R/W)
      SPDRP_FRIENDLYNAME                = $0000000C; {$EXTERNALSYM SPDRP_FRIENDLYNAME} // FriendlyName (R/W)
      SPDRP_LOCATION_INFORMATION        = $0000000D; {$EXTERNALSYM SPDRP_LOCATION_INFORMATION} // LocationInformation (R/W)
      SPDRP_PHYSICAL_DEVICE_OBJECT_NAME = $0000000E; {$EXTERNALSYM SPDRP_PHYSICAL_DEVICE_OBJECT_NAME} // PhysicalDeviceObjectName (R)
      SPDRP_CAPABILITIES                = $0000000F; {$EXTERNALSYM SPDRP_CAPABILITIES} // Capabilities (R)
      SPDRP_UI_NUMBER                   = $00000010; {$EXTERNALSYM SPDRP_UI_NUMBER} // UiNumber (R)
      SPDRP_UPPERFILTERS                = $00000011; {$EXTERNALSYM SPDRP_UPPERFILTERS} // UpperFilters (R/W)
      SPDRP_LOWERFILTERS                = $00000012; {$EXTERNALSYM SPDRP_LOWERFILTERS} // LowerFilters (R/W)
      SPDRP_BUSTYPEGUID                 = $00000013; {$EXTERNALSYM SPDRP_BUSTYPEGUID}// BusTypeGUID (R)
      SPDRP_LEGACYBUSTYPE               = $00000014; {$EXTERNALSYM SPDRP_LEGACYBUSTYPE}// LegacyBusType (R)
      SPDRP_BUSNUMBER                   = $00000015; {$EXTERNALSYM SPDRP_BUSNUMBER}// BusNumber (R)
      SPDRP_ENUMERATOR_NAME             = $00000016; {$EXTERNALSYM SPDRP_ENUMERATOR_NAME} // Enumerator Name (R)
      SPDRP_SECURITY                    = $00000017; {$EXTERNALSYM SPDRP_SECURITY} // Security (R/W, binary form)
      SPDRP_SECURITY_SDS                = $00000018; {$EXTERNALSYM SPDRP_SECURITY_SDS} // Security (W, SDS form)
      SPDRP_DEVTYPE                     = $00000019; {$EXTERNALSYM SPDRP_DEVTYPE} // Device Type (R/W)
      SPDRP_EXCLUSIVE                   = $0000001A; {$EXTERNALSYM SPDRP_EXCLUSIVE} // Device is exclusive-access (R/W)
      SPDRP_CHARACTERISTICS             = $0000001B; {$EXTERNALSYM SPDRP_CHARACTERISTICS}// Device Characteristics (R/W)
      SPDRP_ADDRESS                     = $0000001C; {$EXTERNALSYM SPDRP_ADDRESS}// Device Address (R)
      SPDRP_UI_NUMBER_DESC_FORMAT       = $0000001D; {$EXTERNALSYM SPDRP_UI_NUMBER_DESC_FORMAT}// UiNumberDescFormat (R/W)
      SPDRP_DEVICE_POWER_DATA           = $0000001E; {$EXTERNALSYM SPDRP_DEVICE_POWER_DATA}// Device Power Data (R)
      SPDRP_REMOVAL_POLICY              = $0000001F; {$EXTERNALSYM SPDRP_REMOVAL_POLICY}// Removal Policy (R)
      SPDRP_REMOVAL_POLICY_HW_DEFAULT   = $00000020; {$EXTERNALSYM SPDRP_REMOVAL_POLICY_HW_DEFAULT}// Hardware Removal Policy (R)
      SPDRP_REMOVAL_POLICY_OVERRIDE     = $00000021; {$EXTERNALSYM SPDRP_REMOVAL_POLICY_OVERRIDE}// Removal Policy Override (RW)
      SPDRP_INSTALL_STATE               = $00000022; {$EXTERNALSYM SPDRP_INSTALL_STATE}// Device Install State (R)
      SPDRP_MAXIMUM_PROPERTY            = $00000023; {$EXTERNALSYM SPDRP_MAXIMUM_PROPERTY} // Upper bound on ordinals

    mon portage donne ceci :
    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
     
    Procedure GetUnitsFromClassDevices;
    {--------------------------------------------
      Scanne la classe CD-Rom
      ****
      Sources :
      http://msdn.microsoft.com/library/en-us/devio/base/setupdigetclassdevs.asp
    ---------------------------------------------}
    const
      FuncName : string = 'TDriverInterfaceSPTI.GetUnitsFromClassDevices';
    var
      DevList : HDEVINFO;                           // Liste des périphériques de type CD
      DevInfo : HDEVINFO;
      DevI : Integer;                               // compteur, pour le Ieme périph de la liste
      Success : Boolean;
      DeviceInterfaceData: TSPDeviceInterfaceData;
      DevData: TSPDevInfoData;
      BytesReturned: DWORD;
      FunctionClassDeviceData: PSPDeviceInterfaceDetailData;
    Begin
     
      DevInfo := SetupDiGetClassDevs(@GUID_DEVCLASS_CDROM, nil, 0, DIGCF_PRESENT);
      if (DevInfo = Pointer(INVALID_HANDLE_VALUE)) then Begin
    //    Self.DebugAddMsg(FuncName, 'Impossible d''obtenir le handle');
        Exit;
      End;
     
      { récupère la liste des périph CD }
      DevList := SetupDiGetClassDevs(@CdRomClassGuid, nil, 0, DIGCF_PRESENT or DIGCF_INTERFACEDEVICE);
      if (DevList = Pointer(INVALID_HANDLE_VALUE)) then Begin
    //    Self.DebugAddMsg(FuncName, 'Impossible d''obtenir le handle sur la liste des cd');
        Exit;
      End;
     
      {test}
      DevI := 0;
      Repeat
        Success := GetRegistryProperty(DevInfo, DevI);
        Inc(DevI, 1);
      Until not Success;
    End;
     
     
    Function GetRegistryProperty(DevInfo : HDEVINFO; Index:DWord) : Boolean;
    var
      deviceInfoData : TSPDevInfoData;
      errorCode : DWord;
      bufferSize : DWord;
      dataType : DWord;
      Buffer: array[0..16383] of Char;
      Status : Boolean;
      BytesReturned : dword;
    Begin
      FillChar(deviceInfoData, SizeOf(TSPDevInfoData), #0);
      deviceInfoData.cbSize := SizeOf(SP_DEVINFO_DATA);
      status := SetupDiEnumDeviceInfo(DevInfo, Index, deviceInfoData);
     
      if not Status then Begin
        MessageBox(0, PChar(SysErrorMessage(GetLastError)), '', MB_OK);
        exit;
      End;
     
      BytesReturned := 0;
      Buffer[0] := #0;
      dataType   := 0; 
      status := SetupDiGetDeviceRegistryProperty(DevInfo, deviceInfoData, SPDRP_HARDWAREID, dataType, PBYTE(@Buffer[0]), SizeOf(Buffer), BytesReturned);
      if not Status then Begin
        errorCode := GetLastError;
        MessageBox(0, PChar(SysErrorMessage(GetLastError)), '', MB_OK);
     
        if errorCode = ERROR_INSUFFICIENT_BUFFER then
          Result := TRUE
        Else
          Result := FALSE;
      End;
     
      Result := status;
     
    End;
    malheureusement le code est foireux. la fonction "SetupDiGetDeviceRegistryProperty" me retourne une erreur. un problème de paramètre apparament.


    si quelqu'un voit pourquoi... sans ça, impossible de récupérer un handle correct sur le lecteur. par cette manière du moins.

  10. #10
    Nouveau membre du Club
    Inscrit en
    Novembre 2004
    Messages
    50
    Détails du profil
    Informations forums :
    Inscription : Novembre 2004
    Messages : 50
    Points : 25
    Points
    25
    Par défaut
    j'ai réussi à faire marcher une partie du code, grace à Robert Marquardt l'auteur de http://www.sf.net/projects/jedi-apilib, dont j'utilisais une vieille version de JvHidControllerClass.pas.

    je posterai mon code demain.

    bien que le problème ne soit pas totalement fini.
    Robert m'a indiqué ceci :
    "Drive letters are matched through GetVolumeNameForVolumeMountPoint (which is a Win XP API)"
    ca devrait m'aider un mnimum

Discussions similaires

  1. Gestion des lettres et Lecteur
    Par Ticlaude dans le forum Windows Vista
    Réponses: 15
    Dernier message: 05/03/2008, 20h32
  2. Réponses: 1
    Dernier message: 30/10/2007, 10h38
  3. [C#] Détecter la lettre du lecteur CD-ROM
    Par patvdb dans le forum Windows Forms
    Réponses: 2
    Dernier message: 19/05/2004, 11h44
  4. Lettre Drive lecteur de CDRom
    Par titicurio dans le forum C++Builder
    Réponses: 4
    Dernier message: 18/09/2003, 13h44
  5. [Lecteur] Lettre du lecteur de CD
    Par petit scarabée dans le forum Installation, Déploiement et Sécurité
    Réponses: 6
    Dernier message: 05/09/2002, 18h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo