EnumPrinterDrivers = Zugriffsverletzung (Anfängerfrage)

[Andreas2k]

Ich würde gerne mittels EnumPrinterDrivers die Liste der installierten Druckertreiber auslesen.
Das auslesen funktioniert auch, ich bekomme die korrekte Liste doch dann haut das Programm eine Zugriffsverletzung raus.

Zitat:

---------------------------
Printer
---------------------------
Zugriffsverletzung bei Adresse 004058CF in Modul 'Printer.exe'. Lesen von Adresse 00000000.
---------------------------
OK
---------------------------

Ich bin leider ein wenig aus der übung und habe auch früher solche API geschichten gemieden. Diesmal würde ich aber gerne verstehen wie es geht und wo da der Fehler ist. Im Debugger wirkt es irgendwie als hätte ich zu viel Speicher reserviert.

Delphi-Quellcode:

function GetPrinterDrivers(): boolean;
var
    arDriverList : array of TDriverInfo2;
    pBuffer      : Pointer;
    pcbNeeded    : DWORD;
    pcReturned   : DWORD;
    ErrorTxt     : array [0..500] of char;
    i            : integer;
begin

// Aufruf mit Buffersize 0 soll die benötigte Größe in pcbNeeded schreiben.
// ^--------------------------------------------+
if not EnumPrinterDrivers(nil, nil, 2, pBuffer, 0, pcbNeeded, pcReturned) then
    begin
      GetMem(pBuffer, pcbNeeded);
    end;

result := EnumPrinterDrivers(nil, nil, 2, pBuffer, pcbNeeded, pcbNeeded, pcReturned);

if result then
   begin
     arDriverList := pBuffer;
     for i := 0 to  pcReturned -1 do form1.Memo1.Lines.add(arDriverList[i].pName);
     FreeMem(pBuffer, pcbNeeded);
   end
      else
    begin
      FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, GetLastError, 0, ErrorTxt, 500, nil);
      ShowMessage(ErrorTxt);
    end;
end;

[Der schöne Günther]

Spar dir den Zeiger pBuffer und nimm direkt das Array:

Delphi-Quellcode:

function GetPrinterDrivers(): boolean;
var
    arDriverList : array of TDriverInfo2;
    //pBuffer : Pointer;
     pcbNeeded : DWORD;
     pcReturned : DWORD;
     ErrorTxt : array [0..500] of char;
     i : integer;
begin

// Aufruf mit Buffersize 0 soll die benötigte Größe in pcbNeeded schreiben.
// ^--------------------------------------------+
if not EnumPrinterDrivers(nil, nil, 2, nil, 0, pcbNeeded, pcReturned) then // gib ihm doch einen Nullzeiger statt einen nicht initialisierten!
    begin
      //GetMem(pBuffer, pcbNeeded);
      SetLength(arDriverList, pcbNeeded);
    end;

 result := EnumPrinterDrivers(nil, nil, 2, @arDriverList[0], pcbNeeded, pcbNeeded, pcReturned);

if result then
   begin
     //arDriverList := pBuffer; // nope
     for i := 0 to pcReturned -1 do form10.Memo1.Lines.add(arDriverList[i].pName);
      //FreeMem(pBuffer, pcbNeeded); //macht das array nach verlassen der methode selber
    end
       else
     begin
       FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, GetLastError, 0, ErrorTxt, 500, nil);
       ShowMessage(ErrorTxt);
    end
end;

Der Fehler liegt wohl daran dass du nicht einfach deinen rohen Speicherbereich von x Elementen (C-Array) in dein dynamisches Delphi-Array pressen kannst. Ein Delphi-Array enthält noch mehr Informationen (Anzahl der Elemtente, Referanzzähler). Wochenendlektüre dafür gibt es hier:
http://rvelthuis.de/articles/article...html#dynarrays

In der Regel gibst du WinAPI-Aufrufen, wenn sie einen rohen Zeiger auf einen Speicherbereich haben wollen, die Adresse deines Delphi-Arrays mit Index 0 (siehe oben: "@arDriverList[0]").


PS: Ich glaube ich habe noch nie in meinem Leben (und ich mache jetzt vier Jahre Delphi) GetMem(..)/FreeMem(..) gebraucht...

[Andreas2k]

Herzlichen Dank!
jetzt läuft wirklich rund.

Und danke für den Link :-D

[jus]

Warum eigentlich so kompliziert? Es gibt doch die Unit Printers dafür, oder zumindest bei meinem Delphi 2007.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Printers, StdCtrls;

type
  TForm1 = class(TForm)
    ComboBox1: TComboBox;
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  combobox1.Items:=Printer.Printers;
  combobox1.ItemIndex:=Printer.PrinterIndex;
end;

end.

lg,
jus

[Aviator]

Zitat:

Zitat von jus (Beitrag 1363149)

Warum eigentlich so kompliziert? Es gibt doch die Unit Printers dafür, oder zumindest bei meinem Delphi 2007.

Es geht um die installierten Druckertreiber nicht um die Drucker als solche. :cyclops:

[himitsu]

Das muß auch knallen.

* pBuffer ist beim ersten Aufruf nicht initialisiert (das sollte dir auch dein Compiler um die Ohren hauen)
* GetMem ist nur bei einem ganz bestimmten "Fehler" richtig
* ist nichts installiert, würde cbBuf=0 passen und es gibt keinen Fehler
* und dann ist arDriverList ein Delphi-Array, was absolut garnichts mit dem C-Array zu zun hat
** du "sagst" dem Compiler aber, dass pBuffer dieses Array drin ist, das zufällg so lange gut geht, bis irgendwas auf die Control-Felder (Length und Type) des Delphi-Array zugreifen will, was z.B. am Ende der Prozedur passiert, wenn der Compiler dort den Speicher des Arrays freigeben will.
** das kann maximal in den Zeiger eines statischen

Delphi-Quellcode:

array[0..x] of TDriverInfo2

gecastet werden oder man muß umkopieren, bzw. die Daten direkt in ein bestehendes dynamisches Array reinschreiben

PS: Bei SetLength sollte man natürlich die Anzahl der Records und nicht der Bytes reingeben.

[Der schöne Günther]

Zitat:

Zitat von himitsu (Beitrag 1363162)

PS: Bei SetLength sollte man natürlich die Anzahl der Records und nicht der Bytes reingeben.

Ja, das ist oben in den beiden Quelltexten noch völlig falsch :!:

[Andreas2k]

Zitat:

Zitat von Der schöne Günther (Beitrag 1363167)

Zitat:

Zitat von himitsu (Beitrag 1363162)

PS: Bei SetLength sollte man natürlich die Anzahl der Records und nicht der Bytes reingeben.

Ja, das ist oben in den beiden Quelltexten noch völlig falsch :!:

Das hatte mich anfangs auch gewundert aber der erste aufruf liefert ja nur die benötigten Bytes zurück und nicht die Anzahl Einträge. pcReturned liefert nach dem ersten Aufruf 0 zurück.

Mache ich also ein SetLength(arDriverList, pcReturned);

kommt beim zweiten / finalen aufruf die Fehlermeldung

Zitat:

Der angegebene Benutzerpuffer ist für den angeforderten Vorgang nicht zulässig.

Das war auch der Grund weshalb ich irtümlich Getmem benutzt habe. Ich bekomme einfach nicht die Anz Einträge bis ich eine Buffer übergebe der groß genug ist - sprich pcbNeeded

[Andreas2k]

ich bin bisher immer noch nicht schlauer.

Der erste aufruf

Delphi-Quellcode:

EnumPrinterDrivers(nil, nil, 2, nil, 0, pcbNeeded, pcReturned)

liefert mir nur die benötigte größe in Byte - in meinem Fall sind das 10112 Byte (18 Treiber sind installiert)

mit

Delphi-Quellcode:

SetLength(arDriverList, pcbNeeded);

wird der Array 10112 Einträge groß - aber alles funktioniert.


Wie kann ich anhand der zurückgelieferten Bytes die Anzahl der Array Einträge ermitteln, die ich für ein SetLength benötige?

Oder kann ich dem Array of auch sagen das dieses insgesamt 10112 Bytes groß sein soll?

[Zacherl]

Zitat:

Zitat von Andreas2k (Beitrag 1363747)

Wie kann ich anhand der zurückgelieferten Bytes die Anzahl der Array Einträge ermitteln, die ich für ein SetLength benötige?

Das kommt drauf an. Werden neben den

Delphi-Quellcode:

DRIVER_INFO_2

Strukturen zusätzlich auch die Strings (die in den einzelnen Einträgen per Pointer referenziert werden) oder andere Sachen im Buffer abgelegt?

Nein:
Einfach die Anzahl der Bytes durch

Delphi-Quellcode:

SizeOf(TDriverInfo2)

teilen.

Ja:
In diesem Falle würde ich von Anfang an mit einem untypisiertem Buffer (

Delphi-Quellcode:

GetMem

) arbeiten. In

Delphi-Quellcode:

pcReturned

gibt die API dir die Anzahl der Elemente zurück, also kannst du einfach iterieren:

Delphi-Quellcode:

var
  Buf: PDriverInfo2;
  ..
begin
  // Größe ermitteln, etc ..
  GetMem(Buf, pcbNeeded);
  try
    if EnumPrinterDrivers(...) then
    begin
      for I := 1 to pcReturned do
      begin
        // Mach was
        // ..
        // zum nächsten Element springen
        Inc(Buf);
      end;
    end;
  finally
    FreeMem(Buf);
  end;
end;

[Andreas2k]

SizeOf(TDriverInfo2);

Hatte ich auch schon probiert ergibt bei mir aber 24 byte

pcbNeeded / 24 ergibt aber ( 10112 / 24 = 421 ) obwohl es halt nur 18 Treiber sind. Funktioniert also auch net.

Da ich bei mir ja weiß das ich 18 Treiber installiert habe ergibt sich bei mir ein Teiler von 10112 / 18 = 561 aber der Wert ist nicht überall gleich auf nem anderen Rechner muss der z.B. 429 sein.

Das andere mit GetMem muss ich mir nochmal in Ruhe anschauen..

[Zacherl]

Ok, das bestätigt dann auf jeden Fall meine Vermutung, dass im Buffer auch noch die dazugehörigen Strings abgelegt werden und nicht nur die

Delphi-Quellcode:

DRIVER_INFO_2

Strukturen. Mit dem

Delphi-Quellcode:

GetMem

Beispiel sollte es aber funktionieren. Zur Erklärung:

Delphi-Quellcode:

Buf

ist hier als Zeiger deklariert, welcher nach dem Aufruf der API dann auf die erste

Delphi-Quellcode:

DRIVER_INFO_2

Struktur zeigt. Mit dem

Delphi-Quellcode:

Inc

wird der Zeiger um

Delphi-Quellcode:

SizeOf(TDriverInfo2)

erhöht, zeigt also danach auf das 2./3./n-te Element.

Hier fällt mir grade auf, dass in meinem Beisüiel das

Delphi-Quellcode:

FreeMem

am Ende so natürlich nicht funktioniert, da sich der Zeiger ja geändert hat. Den initialen Buffer-Pointer (direkt nach dem

Delphi-Quellcode:

GetMem

Aufruf) müsstest du dir also sichern, bevor du anfängst zu iterieren.

[Der schöne Günther]

Zitat:

Zitat von Zacherl (Beitrag 1363755)

Vermutung, dass im Buffer auch noch die dazugehörigen Strings abgelegt werden

Wow, das ist aber echt fies. Das erklärt die Rückgabewerte wieviel BYTES man den Puffer bitte groß machen soll. Ich glaube das ist definitiv keine Anfängerfrage mehr :-D

Dann war mein Geschwafel ("kein Puffer, nimm einfach ein Array") definitiv falsch.

[himitsu]

Man kann ja dennoch das Array verwenden, aber dann eben nicht auf alle, sondern nur auf die richige Anzahl der Einträge zugreifen.

[Zacherl]

Kann man dann aber nicht so schön inkrementieren :)

[himitsu]

0 bis daswasdieapisagt-1

BOOL EnumPrinterDrivers(
_In_ LPTSTR pName,
_In_ LPTSTR pEnvironment,
_In_ DWORD Level,
_Out_ LPBYTE pDriverInfo,
_In_ DWORD cbBuf,
_Out_ LPDWORD pcbNeeded,
_Out_ LPDWORD pcReturned
);

[Andreas2k]

Dumme Frage aber kann ich es nicht auch einfach so machen:
statt 2x EnumPrinterDrivers aufzurufen rufe ich es 3x auf (1x um die nötige Buffersize zu ermitteln, 1x mit dem pBuffer in der Größe von BytesNeeded um den ItemsCount zu erhalten, 1x der finale aufruf mit dem @array[0] (=SetLength(array, ItemsReturned))

Delphi-Quellcode:

function GetPrinterDrivers(): boolean;
var
     aDriverList     : array of TDriverInfo2;
     pBuffer         : Pointer;
     BytesNeeded     : DWORD;
     ItemsReturned   : DWORD;
     ErrorTxt        : array [0..500] of char;
     i               : integer;
begin

// BufferSize ermitteln
if not EnumPrinterDrivers(nil, nil, 2, nil, 0, BytesNeeded, ItemsReturned) then
    begin
      if GetLastError = ERROR_INSUFFICIENT_BUFFER then
         begin
           try
            // pBuffer Speicher reservieren
            pBuffer := System.AllocMem(BytesNeeded);
            // Anz. Items des Arrays ermitteln
            if EnumPrinterDrivers(nil, nil, 2, pBuffer, BytesNeeded, BytesNeeded, ItemsReturned) then
                begin
                  // Array Länge setzen
                  SetLength(aDriverList, ItemsReturned);
                  result := EnumPrinterDrivers(nil, nil, 2, @aDriverList[0], BytesNeeded, BytesNeeded, ItemsReturned);
                end;
           finally
            // Speicher freigeben
            FreeMem(pBuffer);
           end;
         end;
    end;

Kann man das so machen oder ist das zu gefährlich / dümmlich ?:|

[Zacherl]

Zitat:

Zitat von himitsu (Beitrag 1363790)

Man kann ja dennoch das Array verwenden, aber dann eben nicht auf alle, sondern nur auf die richige Anzahl der Einträge zugreifen.

Zitat:

Zitat von himitsu (Beitrag 1363798)

0 bis daswasdieapisagt-1

BOOL EnumPrinterDrivers(
_In_ LPTSTR pName,
_In_ LPTSTR pEnvironment,
_In_ DWORD Level,
_Out_ LPBYTE pDriverInfo,
_In_ DWORD cbBuf,
_Out_ LPDWORD pcbNeeded,
_Out_ LPDWORD pcReturned
);

Aber das Problem ist ja, dass

Delphi-Quellcode:

pcbNeeded

in Bytes angegeben ist und ausdrücklich nicht

Delphi-Quellcode:

pcReturned * SizeOf(DRIVER_INFO_2)

ist. Nichtmal ein Vielfaches von

Delphi-Quellcode:

SizeOf(DRIVER_INFO_2)

ist garantiert. Mit einem

Delphi-Quellcode:

Array of DRIVER_INFO_2

zu arbeiten, macht doch rein von der Logik her einfach keinen Sinn.

Zitat:

Zitat von Andreas2k (Beitrag 1364040)

Kann man das so machen oder ist das zu gefährlich / dümmlich ?:|

Macht wenig Sinn. Der 3. Aufruf der API wird fehlschlagen (bzw. noch schlimmer: zufälligen Speicher überschreiben), da dein Array nach wie vor die falsche Größe hat. Siehe oben:

Delphi-Quellcode:

pcbNeeded

ist kein Vielfaches von

Delphi-Quellcode:

SizeOf(DRIVER_INFO_2)

. Der Array Ansatz kann nicht funktionieren - du hast enweder zu wenig Platz = Buffer Overflow oder du reservierst zu viel = Logisch fragwürdig. Arrays sollte man wirklich nur dann verwenden, wenn man homogene Strukturen zusammenfassen will.

Delphi-Quellcode:

function EnumPrinterDriversW(pName: LPSTR; pEnvironment: LPSTR; Level: DWord; pDriverInfo: LPBYTE;
  cbBuf: DWord; var pcbNeeded: DWord; var cbReturned: DWord): BOOL; stdcall;
  external 'winspool.drv';

type
  DRIVER_INFO_2 = packed record
    cVersion: DWord;
    pName: LPTSTR;
    pEnvironment: LPTSTR;
    pDriverPath: LPTSTR;
    pDataFile: LPTSTR;
    pConfigFile: LPTSTR;
  end;
  PDriverInfo2 = ^TDriverInfo2;
  TDriverInfo2 = DRIVER_INFO_2;

procedure TForm6.FormCreate(Sender: TObject);
var
  Buf: Pointer;
  ErrorCode,
  pcbNeeded,
  cbReturned,
  I: DWord;
  Driver: PDriverInfo2;
begin
  EnumPrinterDriversW(nil, nil, 2, nil, 0, pcbNeeded, cbReturned);
  ErrorCode := GetLastError;
  if (ErrorCode <> ERROR_INSUFFICIENT_BUFFER) then
  begin
    RaiseLastOsError(ErrorCode);
  end;
  GetMem(Buf, pcbNeeded);
  try
    if (not EnumPrinterDriversW(nil, nil, 2, Buf, pcbNeeded, pcbNeeded, cbReturned)) then
    begin
      RaiseLastOsError;
    end;
    Driver := Buf;
    for I := 1 to cbReturned do
    begin
      ShowMessage(Driver^.pName);
      Inc(Driver);
    end;
  finally
    FreeMem(Buf);
  end;
end;

Wenn der Zugriff umbedingt über ein Array erfolgen soll, dann geht auch folgende Variante:

Delphi-Quellcode:

procedure TForm6.FormCreate(Sender: TObject);
type
  PDriverInfo2Array = ^TDriverInfo2Array;
  TDriverInfo2Array = array[0..0] of TDriverInfo2;
var
  Buf: Pointer;
  ...
  I: DWord;
  Drivers: PDriverInfo2Array;
begin
  ...
  try
    ...
    Drivers := Buf;
    for I := 0 to cbReturned - 1 do
    begin
      ShowMessage(Drivers^[I].pName);
    end;
  finally
    ...
  end;
end;

[Andreas2k]

Ok, ich hab es jetzt wie in deinem ersten Beispiel gemacht.
Ist das mit pStart und FreeMem so in Ordnung?

Delphi-Quellcode:

function GetPrinterDrivers(): boolean;
var
     Buffer          : PDriverInfo2;
     pStart          : Pointer;
     i               : Integer;
     BytesNeeded     : DWORD;
     ItemsReturned   : DWORD;

begin

if not EnumPrinterDrivers(nil, nil, 2, nil, 0, BytesNeeded, ItemsReturned) then
    begin
      if GetLastError = ERROR_INSUFFICIENT_BUFFER then
        begin
          GetMem(Buffer, BytesNeeded);
          pStart := Buffer;
          try
            if  EnumPrinterDrivers(nil, nil, 2, Buffer, BytesNeeded, BytesNeeded, ItemsReturned) then
               begin
                 for i := 1 to ItemsReturned  do
                     begin
                       Form1.Memo1.Lines.Add(i.ToString +' :: '+Buffer.pName);
                       inc(Buffer);
                     end;
               end;

          finally

            Buffer := pStart;
            FreeMem(Buffer);
          end;
        end;
    end;

[Der schöne Günther]

Auch wenn ich schon einmal Quark erzählt habe traue ich mich trotzdem noch:

Sieht gut aus, allerdings
- Könnte man pStart auch vom Typ PDriverInfo2 sein lassen.
- Mach in der Doku unbedingt fest was deine Methode denn angeblich zurückgibt
- Denn momentan ist der Rückgabewert uU nicht definiert

[himitsu]

Es muß nur mindestens so viel Speicher bereitgestellt werden, wie nötig.
Also wäre es kein Problem den Speicher auf ganze Recordgrößen aufzurunden.

Und nein, denn
* erstmal wäre der dritte Aufruf garnicht nötig, da man im Zweiten bereits beide Größen erfährt
** einfach ein SetLength zum Kürzen nach dem 2. Aufruf (was man aber nicht machen darf)
* außerdem würde man dann den Speicher mit den Strings freigeben, womit die PChars in den Records ins Nirvana zeigen täten

[Andreas2k]

Zitat:

Zitat von Zacherl (Beitrag 1364044)

Zitat:

Zitat von himitsu (Beitrag 1363790)

Man kann ja dennoch das Array verwenden, aber dann eben nicht auf alle, sondern nur auf die richige Anzahl der Einträge zugreifen.

Zitat:

Zitat von himitsu (Beitrag 1363798)

0 bis daswasdieapisagt-1

BOOL EnumPrinterDrivers(
_In_ LPTSTR pName,
_In_ LPTSTR pEnvironment,
_In_ DWORD Level,
_Out_ LPBYTE pDriverInfo,
_In_ DWORD cbBuf,
_Out_ LPDWORD pcbNeeded,
_Out_ LPDWORD pcReturned
);

Aber das Problem ist ja, dass

Delphi-Quellcode:

pcbNeeded

in Bytes angegeben ist und ausdrücklich nicht

Delphi-Quellcode:

pcReturned * SizeOf(DRIVER_INFO_2)

ist. Nichtmal ein Vielfaches von

Delphi-Quellcode:

SizeOf(DRIVER_INFO_2)

ist garantiert. Mit einem

Delphi-Quellcode:

Array of DRIVER_INFO_2

zu arbeiten, macht doch rein von der Logik her einfach keinen Sinn.

Zitat:

Zitat von Andreas2k (Beitrag 1364040)

Kann man das so machen oder ist das zu gefährlich / dümmlich ?:|

Macht wenig Sinn. Der 3. Aufruf der API wird fehlschlagen (bzw. noch schlimmer: zufälligen Speicher überschreiben), da dein Array nach wie vor die falsche Größe hat. Siehe oben:

Delphi-Quellcode:

pcbNeeded

ist kein Vielfaches von

Delphi-Quellcode:

SizeOf(DRIVER_INFO_2)

. Der Array Ansatz kann nicht funktionieren - du hast enweder zu wenig Platz = Buffer Overflow oder du reservierst zu viel = Logisch fragwürdig. Arrays sollte man wirklich nur dann verwenden, wenn man homogene Strukturen zusammenfassen will.

Delphi-Quellcode:

function EnumPrinterDriversW(pName: LPSTR; pEnvironment: LPSTR; Level: DWord; pDriverInfo: LPBYTE;
  cbBuf: DWord; var pcbNeeded: DWord; var cbReturned: DWord): BOOL; stdcall;
  external 'winspool.drv';

type
  DRIVER_INFO_2 = packed record
    cVersion: DWord;
    pName: LPTSTR;
    pEnvironment: LPTSTR;
    pDriverPath: LPTSTR;
    pDataFile: LPTSTR;
    pConfigFile: LPTSTR;
  end;
  PDriverInfo2 = ^TDriverInfo2;
  TDriverInfo2 = DRIVER_INFO_2;

procedure TForm6.FormCreate(Sender: TObject);
var
  Buf: Pointer;
  ErrorCode,
  pcbNeeded,
  cbReturned,
  I: DWord;
  Driver: PDriverInfo2;
begin
  EnumPrinterDriversW(nil, nil, 2, nil, 0, pcbNeeded, cbReturned);
  ErrorCode := GetLastError;
  if (ErrorCode <> ERROR_INSUFFICIENT_BUFFER) then
  begin
    RaiseLastOsError(ErrorCode);
  end;
  GetMem(Buf, pcbNeeded);
  try
    if (not EnumPrinterDriversW(nil, nil, 2, Buf, pcbNeeded, pcbNeeded, cbReturned)) then
    begin
      RaiseLastOsError;
    end;
    Driver := Buf;
    for I := 1 to cbReturned do
    begin
      ShowMessage(Driver^.pName);
      Inc(Driver);
    end;
  finally
    FreeMem(Buf);
  end;
end;

Vielen Dank,
ich glaube langsam verstehe ich die Problematik und es macht jetzt auch Sinn das ein Element von DriverInfo2 immer 24 Byte groß ist und somit das Array nicht funktioniert.

Ich werde es jetzt nach deinem Beispiel machen was für mich jetzt endlich Sinn ergibt :-D