Freigegebene Festplatten eines PCs ermitteln

[Salomon]

Hallo,
weiß jemand wie ich die freigebenen Festplatten eines Netzwerk PCs ermitteln kann?
Ich stelle mir das so vor, das ich einer Funktion eine IP Adresse übergebe und diese dann den PC nach freigegebenen Resourcen scannt und sie mir zurückliefert.

Das "WNetOpenEnum Demo" habe ich mir auch schon angeschaut. Dort wird aber immer das ganze Netz durchsucht, was für meine Zwecke nicht sinnvoll ist. Ich möchte eben speziell einzelne PCs abfragen.

Mfg Salomon

[Chewie]

Schau dir mal im MSDN die Funktionen WNetEnumResource oder NetShareEnum an.

[Salomon]

Welche Unit muss ich denn einbinden damit ich "NetShareEnum" benutzten kann? Oder gibt es gar keine Header files?

[Chewie]

Keine Ahnung, ob es da Übersetzungen gibt. Ich schau mal...

Bei meinem Delphi ist nix dabei. Aber schau mal bei den Jedis vorbei, die haben vielleicht die Header-Übersetzungen für diese Funktionen.

[CalganX]

Wie Chewie geschrieben hat, brauchst du die Headerüerbsetzungen der Jedis. Sonst geht das nicht.
Du brauchst den Heder Lmshare.h

Chris

[Salomon]

Ok, danke. Schau ich mir gegen Abend mal genauer an.

[Salomon]

Die passenden Jedi Header habe ich jetzt, allerdings bringt mich das leider nicht weiter :(
Die Net Funktionen (Lan Manager funktionen) sind zu alt, und werden im neuen WinXP nicht mehr unterstützt. Die benötigte "SvrApi.dll" ist kein Bestandteil des Betriebssystem mehr.

Bleiben also nur noch die WNet Funktionen, mit denen ich allerdings nicht zurecht komme.
Mir ist bei den Funktionen überhauptnicht ersichtlich wie ich einzelne Rechner ansprechen an. Ein wenig Hilfe wäre nicht schlecht, bin am verzweifeln :cry:

[Chewie]

Nicht ganz. Schau mal ins SDK, dann siehst du Folgendes:

Zitat:

Zitat von Windows SDK

Library: Use Netapi32.lib (Windows NT/2000/XP) or Svrapi.lib (Windows 95/98/Me)

Du brauchst also nicht die svrapi.dll, sondern die netapi32.dll. Und die hast du in deinem System32-Verzeichnis.

[Salomon]

Die Jedi Header Files setzten auf die Svrapi.dll auf, und sind nicht geeignet.
Daher habe ich die NetSharEnum nun direkt implementiert. Der Code läst sich auch kompelieren, aber ich erhalte keine Freigaben zurück :?
Hast du eine Idee woran das liegen könnte? Hier der Quellcode:

Delphi-Quellcode:

const
    LM20_NNLEN = 12;
    SHPWLEN = 8;
    SHI50F_RDONLY = 1;
    SHI50F_FULL = 2;
    STYPE_DISKTREE = 0;
    
    MaxNetArrayItems=512;

type
TShareInfo50 = packed record
    shi50_netname: array[0..LM20_NNLEN] of Char;
    shi50_type: Byte;
    shi50_flags: Short;
    shi50_remark: PChar;
    shi50_path: PChar;
    shi50_rw_password: array[0..SHPWLEN] of Char;
    shi50_ro_password: array[0..SHPWLEN] of Char;
end;

type
TShareInfo0 = packed record
    shi0_netname  : array[0..LM20_NNLEN] of Char;
end;

  Function NetShareEnum(const pszServer: PChar; sLevel: SmallInt;
    pbBuffer: Pointer; cbBuffer: Word; var pcEntriesRead: Word;
    var pcTotalAvail: Word): DWORD; stdcall; external 'netapi32.dll';

Alle Freigaben sollen in einer Combobox aufgelistet werden, es kommt aber nichts an???

Delphi-Quellcode:

procedure TForm3.SpeedButton2Click(Sender: TObject);
Var
ShareInfo:Array[0..MaxNetArrayItems-1] Of TShareInfo50;
EntriesRead, TotalAvial:Word;
Res:Integer;
i:Integer;

begin
FillChar(ShareInfo,SizeOf(ShareInfo),#0);
Res:=NetShareEnum(0,50,@ShareInfo,SizeOf(ShareInfo), EntriesRead,TotalAvial);

If Res = No_Error Then
For i:=0 To EntriesRead -1 Do
If Not (String(ShareInfo[i].shi50_netname)='') Then
combobox1.Items.Add(String(ShareInfo[i].shi50_netname));
end;

Ideen was falsch ist, oder warum ich keine Freigaben zurück erhaltet?

Thanx Salomon

[Christian Seehase]

Moin Salomon,

Du hast Dich durchgängig an die Deklarationen für 9x/ME gehalten, zum einen was das Einbinden der Funktion, zum anderen, was die verwendete Struktur angeht.
Für XP musst Du aber die NT/2000/XP Versionen verwenden.

Delphi-Quellcode:

const
  NERR_Success         = 0;
  MAX_PREFERRED_LENGTH = DWORD(-1);

type
  NET_API_STATUS = type DWORD;

  PSHARE_INFO_0 = ^SHARE_INFO_0;
  SHARE_INFO_0 =
    packed record
      shi0_netname : PWChar;
    end;

function NetApiBufferFree(
    const Buffer : Pointer
    ) : NET_API_STATUS; stdcall; external 'netapi32.dll';

function NetShareEnum(
    const servername    : PWChar;
    const level         : DWord;
    const bufptr        : Pointer;
    const prefmaxlen    : DWord;
    const entriesread   : PDWord;
    const totalentries  : PDWord;
    const resume_handle : PDWord
    ) : NET_API_STATUS; stdcall; external 'netapi32.dll';


var
  si0Work        : PSHARE_INFO_0;
  si0Save        : PSHARE_INFO_0;
  dwEntriesRead  : DWORD;
  dwTotalEntries : DWORD;
  i              : DWORD;

begin
  if NetShareEnum(nil,0,@si0Work,MAX_PREFERRED_LENGTH,@dwEntriesRead,@dwTotalEntries,nil) <> Nerr_Success then exit;
  try
    si0Save := si0Work;
    for i := 1 to dwEntriesRead do
    begin
      ComboBox1.Items.Add(si0Save.shi0_netname);
      inc(si0Save);
    end;
  finally
    NetApiBufferFree(si0Work);
  end;
end;

Wichtig hierbei:
Ich verwende für die Funktionsdeklarationen immer die C-typische Variante, während die Jedis, meines Wissens, immer die Borland typische Variante nehmen (var Parameter)

[Salomon]

Hallo Christian Seehase,
das sieht ja sehr gut aus. Ich dachte irgendwie die 9x Variante könnte auch auf NT Rechner zugreifen, naja falsch gedacht.
Ich probier das ganze gegen Mittag aus, jetzt hau ich mich erstmal aufs Ohr. Schonmal vielen Dank, ich meld mich dann nochmal hier.

Gute Nacht
Salomon

[Salomon]

Es funktioniert :D Die Funktion findet auf meinem XP Rechner sogar versteckte Freigaben die mir gar nicht bekannt waren.
Da ich ja nur die freigegebenen Festplatten brauche, habe ich noch kleine Änderungen vorgenommen. Hier ist der Code für die übrigen DPler:

Einmal die Deklaration für "Share_Info_2". Dieser ermittelt auch den Freigaben Typ in "shi2_type":

Delphi-Quellcode:

type
  PSHARE_INFO_2 =^SHARE_INFO_2;
  SHARE_INFO_2 = packed record
     shi2_netname      : PWChar;
     shi2_type         : Dword;
     shi2_remark       : PWChar;
     shi_permissions   : DWord;
     shi2_max_uses     : DWord;
     shi2_current_uses : DWord;
     shi2_path         : PWChar;
     shi2_passwd       : PWChar;
    end;

Und hier das Auflisten von freigegebenen Festplatten.

Delphi-Quellcode:

procedure TForm3.SpeedButton2Click(Sender: TObject);
var 
  si2Work        : PSHARE_INFO_2;
  si2Save        : PSHARE_INFO_2;
  dwEntriesRead  : DWORD; 
  dwTotalEntries : DWORD; 
  i              : DWORD;
begin
  if NetShareEnum(nil,2,@si2Work,MAX_PREFERRED_LENGTH,@dwEntriesRead,@dwTotalEntries,nil) <> Nerr_Success then exit;
  try
    si2Save := si2Work;
    for i := 1 to dwEntriesRead do 
    begin
      if si2Save.shi2_type = STYPE_DISKTREE then
           ComboBox1.Items.Add(si2Save.shi2_netname);
      inc(si2Save);
    end; 
  finally
    NetApiBufferFree(si2Work);
  end; 
end;

Eine Frage hätte ich aber noch. Wie schaffe ich es, das mein Programm auch unter 9x funktioniert :?: Hier sind die benötigten Funktionen ja in der "SvrApi.dll".

Thx Salomon

[Chewie]

Zitat:

Zitat von Salomon

Eine Frage hätte ich aber noch. Wie schaffe ich es, das mein Programm auch unter 9x funktioniert :?: Hier sind die benötigten Funktionen ja in der "SvrApi.dll".

Thx Salomon

1.Möglichkeit: Du bietest zwei Möglichkeiten deines Programms an, eines für 9x/ME und eines für NT/2K/XP.

2. Möglichkeit: Mit GetVersion oder GetVersionEx überprüfst du die Win-Version und bindest die entsprechende DLL dynamisch ein.

[Salomon]

@ Chewie: Dann werde ich die zweite Version realisieren. So eine Funktion die mir die Windowsversion zurückliefert habe ich schonmal irgendwo verwendet.

@ Alle: Leider stehe ich schon vor dem nächsten Problem :( So lange mit dem Code der lokale Rechner abgefragt wird läuft alle einwandfrei. Versuche ich aber die freigegebenen Festplatten meines Zweitrechners (auch XP) abzufragen, bekomme ich den ErrorCode 5 zurück => Access Denied (kein Zugriff).
Das kann aber eigentlich nicht sein, da ich über die Netzwerkumgegbung ganz normal ohne Passwort auf die Festplatten mit Lese- und Schreibrechten zugreifen kann.

Vielleicht hat ja einer von euch eine Idee woran das leigen könnte, oder kann den obigen Code mal bei sich im Netzwerk ausprobieren. Andere Rechner fragt man durch eine kleine Änderung ab:

Delphi-Quellcode:

Var
 ...
 res            : integer;
begin
   res := NetShareEnum('\\hier die IP des anderen Rechners\',2,@si2Work,MAX_PREFERRED_LENGTH,@dwEntriesRead,@dwTotalEntries,nil);
   showmessage(inttostr(res));

...

Thx Salomon

[Christian Seehase]

Mion Salomon,

das sollte auch genauso mit einer IP-Adresse, oder dem Rechnernamen funktionieren, ab Windows 2000 auch ohne \\.

Das bei Dir die Funktion auf einen Access Denied läuft kann ich mir im Moment nur damit erklären, dass Du auf den anderen Rechnern keine Admin-Rechte hast, denn die Funktion listet ja auch versteckte und administrative Freigaben (wie C$, D$ usw.) auf.

Bei den Versionen für 9x musst Du übrigens aufpassen. Diese werden auch anders verwendet als unter NT ff. Unter 9x/ME muss z.B. der Buffer selber reserviert werden, was die NT Varianten selber erledigen.

Am Besten schaust Du Dir mal die Doku dazu an. Entweder im PSDK, oder online unter msdn.microsoft.com.

[Salomon]

Argh, wer lesen kann ist klar im Vorteil...

Zitat:

Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareEnum function at levels 2 and 502. No special group membership is required for level 0 or level 1 calls.

Ich habe das ganze jetzt auf Level 1 realisiert, klappt wunderbar :)

[TuXX]

Sicherlich werdet ihr mich jetzt für depperd halten,
aber koennte das mal einer als unit posten,
bin zu bleed das zu implementieren...


mfg

TuXX

[Christian Seehase]

Moin TuXX,

erst einmal herzlich willkommen hier in der Delphi-PRAXiS.

Da sich mit den Codes auf der ersten Seite dieses Threads das ganze nahezu per Copy&Paste implementieren liesse:

Was hast Du denn genau vor, und woran scheitert es?

[TuXX]

Erstmal: Vielen Dank für das herzliche Wilkommen.

Mein "Problem" hat sich schon erledigt,
Es ging wirklich mit copy 'n paste..

Vvielen Dank trozdem

TuXX

[Captnemo]

Hi,

tolles Thema, da ich mich auch gerade damit beschäftige. Ich habe euren Thread verfolgt, und mir dann auch die Jedi-Libary heruntergeladen.
Allerdings möchte ich nicht die Freigaben abfragen, sondern eine neue erstellen (unter XP).
Dabei habe ich dann auch gleich Probleme. Hat einer einen Bespielcode der mir hier weiterhilft?

Danke.

[lord]

Sorry das ich den verstaubten Thread hier nochmal ausgrabe, aber wo finde ich denn die WNetOpenEnum Demo, von der Salomon sprach? Bei Google habe ich neben dem Thread hier noch ein paar russische (mir nichtssagende) Seiten und diesen Thread (den ich vor der Suche schon kannte :wink: ) gefunden.

für sachdienliche Hinweise wäre ich sehr dankbar
mfg lord

[vegdoen]

Hallo Leute,

könnte jemand mal den ganzen Quelltext posten!!!!! :mrgreen: Bitte!!! Ich hab zwar Ahnung von Delphi, aber ich habe jetzt schon mehrmals versucht das Prog selbst zu compilieren, bin aber immer gescheitert, immer an anderen Stellen. :oops: Währe also jmd so freundlich den Quelltext zu posten, am besten die Ausgabe in einer ListBox.

vielen Dank im Vorraus!!!111!!

[Luckie]

Wird das gleiche sein, wie beim Usermanager:

Zitat:

Zitat von XP Usermanager Hilfe

Einschränkungen
Der Usermanger erlaubt es auch lokale Benutzer auf anderen Rechnern im Netzwerk zu verwalten. Bevor auf den remote Rechner zugegriffen wird, wird nun erst eine Freigabe erstellt. Dabei hat man die Möglichkeit bei der Auswahl eines Computers die Freigabe über ein Benutzerkonto zu erstellen durch die Eingabe von Benutzernamen und Passwort.

Da Windows XP Home keinen remote Zugriff zulässt, ist es nicht möglich in einem Netzwerk remote auf einen Rechner mit Windows XP Home zuzugreifen.

Unter Umständen kann es auch Probleme mit XP Professional geben, hierfür gibt es aber eine einfache Problemlösung. Der Grund dafür liegt in der aktivierten ForceGuest-Einstellung die man aber abstellen kann, indem man in der lokalen Sicherheitsrichtlinien "Netzwerkzugriff: Modell für gemeinsame Nutzung und Sicherheitsmodell für lokale Konten" auf "Klassisch" stellt. Die andere Möglichkeit ist, den Wert direkt über die Registrierung zu ändern (dieser befindet sich unter "HKLM\SYSTEM\CurrentControlSet\Control\Lsa -> Schlüssel: forceguest, Wert: 0 (deaktiviert)).

Wichtig: Diese Einstellung ist unter XP standardmäßig aktiv und kann nicht so einfach geändert werden, da sie die Sicherheit des Systems gefährden kann! Ist diese Funktion deaktiviert so kann ein Angreifer leicht auf das System zugreifen, wenn das Administrator-Konto nicht passwortgeschützt ist. Sie sollten sich also bewusst sein, was Sie tun, wenn sie diese Einstellung ändern!

Desweitern musst du dich an dem Remoterechner erst authentifizieren. Ich habe das beim Usermanager so gelöst, dass ich eine Freigabe auf dem Rechner erzeuge:

Zitat:

Zitat von XP Usermanager Hilfe

Hinweis: Wollen Sie auch Änderungen an Konten auf dem remote Rechner vornehmen, ist es erforderlich, dass Sie sich mit einem Benutzerkonto authentifizieren, welches der Administratorengruppe auf dem remote Rechner angehört.

Das bedingt aber dass du die Freigabe mit einem Administratorkonto auf dem Remoterechner erzeugst, desweiteren muss dieses Konto ein Passwort haben. Dsa heißt, du musst Bneutzername und Passwort eines Administrators auf dem Remoterechner angeben und diese muss ein Passwort haben.

[Troelli]

Hallo erstmal :)
Ist schon länger her das diese Threat beschrieben wurde. Aber ich stehe jetzt vor dem Problem das ich meine Shares im Netzwerk abrufen möchte. Nach dem hier veröffentlichten Quellcode geht es auch teilweise bis zur stelle wo man einen anderen Rechner ansprechen will. Dann knallts.
Hat einer eine Idee worann es liegen kann?

Delphi-Quellcode:

unit Unit3;

interface
uses
  Windows,  SysUtils, Classes ,Dialogs ;

const
  NERR_Success         = 0;
  MAX_PREFERRED_LENGTH = DWORD(-1); 

  type
    NET_API_STATUS = DWORD;
    SHARE_INFO_2   = record
    shi2_netname     :  PWideChar;
    shi2_type        :  DWORD;
    shi2_remark      :  PWideChar;
    shi2_permissions :  DWORD;
    shi2_max_uses    :  DWORD;
    shi2_current_uses:  DWORD;
    shi2_path        :  PWideChar;
    shi2_passwd      :  PWideChar;
  end;

  PSHARE_INFO_2  = ^SHARE_INFO_2;
  Procedure EnumNetwork (var EnumNetworkStringlist :TStringlist;Computername_or_IP:String);


  function NetShareEnum(ServerName   : PWideChar;
                        Level        : DWORD;
                        bufptr       : Pointer;
                        PrefMaxLen   : DWORD;
                        EntriesRead  : PDWORD;
                        TotalEntries : PDWORD;
                        Resume_Handle: PDWORD):NET_API_STATUS;
                        stdcall; external 'NetAPI32.dll' name 'NetShareEnum';
  function NetApiBufferFree(Buffer: Pointer): NET_API_STATUS;
                        stdcall; external 'NetAPI32.dll' name 'NetApiBufferFree';



implementation

Procedure EnumNetwork (var EnumNetworkStringlist :TStringlist;Computername_or_IP:String);
const
  MAX_PREFERRED_LENGTH = -1;
  NERR_SUCCESS         = 0;
var
  ER : DWORD; // enries read
  TE : DWORD; // total entries
  ResHandle : DWORD;
  ShareInfo : PSHARE_INFO_2;
  p         : pChar;
  fResult   : NET_API_STATUS;
  i         : Integer;
  share, path : string;
  myWideString  : WideString;
  myWideCharPtr : PWideChar;
begin
  ResHandle := 0;
  fResult := NetShareEnum(nil, 2, @ShareInfo, DWORD(MAX_PREFERRED_LENGTH), @ER, @TE, @ResHandle);
  if(fResult <> NERR_SUCCESS)then
   Exit;
  p := Pointer(ShareInfo);
  for i := 0 to TE - 1 do
  begin
    share := WideCharToString(PSHARE_INFO_2(p)^.shi2_netname);
    path  := WideCharToString(PSHARE_INFO_2(p)^.shi2_path);
    if path<>'' then path:=', '+path;
    EnumNetworkStringlist.Add(share+path);
    p := p + SizeOf(SHARE_INFO_2);
  end;
  NetApiBufferFree(@ShareInfo);
end;
end.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
Computerressourcen:TStringlist;
begin
Computerressourcen:=tstringlist.Create;
Computerressourcen.Add('Testobgeht');

EnumNetwork(Computerressourcen,'192.168.178.1');
ListBox1.Items:= Computerressourcen;
showmessage('fertig');
end;

[Phoenix]

Zitat:

Zitat von Troelli

Dann knallts.

:roll: Dann mach Deine Lautsprecher leiser :roll:
Was knallt denn? Hast Du uns nicht wenigstens mal ne Fehlermeldung?

[Troelli]

Ok ... Das knallen^^ konnte ich abstellen. Hatte eine Variable falsch deklariert.
Meine Ressourcen auf Meinem Rechner werden dargestellt. Jedoch nicht die Ressorcen der anderen Rechner im Netzwerk. Das sind normale Freigaben ohne Passwort und Schreibschutz.

NetShareEnum(nil, 2, @ShareInfo, DWORD(MAX_PREFERRED_LENGTH), @ER, @TE, @ResHandle) <<< funktioniert

NetShareEnum(andereIPadresse, 2, @ShareInfo, DWORD(MAX_PREFERRED_LENGTH), @ER, @TE, @ResHandle)<<<< funktioniert nicht.

Es wird gar nichts angezeigt. Kein Fehler keine Daten.
Wenn ich jetzt den Userlevel ändere in 1 oder 0 gibt es eine Exception EAccesViolation.

[Christian Seehase]

Moin Troelli,

erst einmal herzlich willkommen hier in der Delphi-PRAXiS.

Hattest Du den Code selber geschrieben, oder kopiert?

Da ich mit den Lanmanager Funktionen schon einiges gemacht habe, hab' ich es mal angepasst, und kommentiert.
So funktioniert es bei mir auch bei anderen Rechnern:

Delphi-Quellcode:

const
  NERR_Success          = 0;
  MAX_PREFERRED_LENGTH  = DWORD(-1); // Einmal deklarieren reicht ;-)

type
  NET_API_STATUS = DWORD;
  PSHARE_INFO_2  = ^SHARE_INFO_2; // kann zwar auch danach deklariert werden,
                                  // aber davor ist halt üblich
  SHARE_INFO_2   = packed record  // Auch wenn es hier keine Rolle spielt: 
                                  // packed ist bei API-Funktionen meist besser
    shi2_netname     :  PWideChar;
    shi2_type        :  DWORD;
    shi2_remark      :  PWideChar;
    shi2_permissions :  DWORD;
    shi2_max_uses    :  DWORD;
    shi2_current_uses:  DWORD;
    shi2_path        :  PWideChar;
    shi2_passwd      :  PWideChar;
  end;

  // Beides auf const geändert
  // Die Strings werden ja nicht in der Prozedur erzeugt, sondern gefüllt: da reicht const
  // Nimmt man TStrings kann man auch, z.B., ListBox.Items, und sonstige von TStrings
  // abgeleitete Listen übergeben
  // Für den Namen/Adresse kann auch nil angegeben werden: Geht ohne const nicht
  Procedure EnumNetwork (const EnumNetworkStringlist :TStrings;const Computername_or_IP:PWideChar);

  // Auch alles auf const geändert, da man so besser die Beispiele (meist in C geschrieben)
  // besser nachvollziehen kann
  function NetShareEnum(const ServerName   : PWideChar;
                        const Level        : DWORD;
                        const bufptr       : Pointer;
                        const PrefMaxLen   : DWORD;
                        const EntriesRead  : PDWORD;
                        const TotalEntries : PDWORD;
                        const Resume_Handle: PDWORD):NET_API_STATUS;
                        stdcall; external 'NetAPI32.dll' name 'NetShareEnum';
  function NetApiBufferFree(const Buffer: Pointer): NET_API_STATUS;
                        stdcall; external 'NetAPI32.dll' name 'NetApiBufferFree';


implementation

{$R *.dfm}

Procedure EnumNetwork (const EnumNetworkStringlist :TStrings;const Computername_or_IP:PWideChar);

var
  dwEntriesRead  : DWORD;
  dwTotalEntries : DWORD;
  dwResHandle    : DWORD;
  LShareInfo     : PSHARE_INFO_2;  
  LsiWork        : PSHARE_INFO_2;  // Auch die Arbeitsvariable sollte den Typ haben
  dwResult       : NET_API_STATUS;
  i              : Integer;

begin
  EnumNetworkStringlist.Clear;
  dwResHandle := 0;
  dwResult := NetShareEnum(Computername_or_IP,2,@LShareInfo,MAX_PREFERRED_LENGTH,@dwEntriesRead,@dwTotalEntries,@dwResHandle);
  if(dwResult <> NERR_SUCCESS)then begin
    // Im Fehlerfalle einfach mal sehen, was es war
    ShowMessage(SysErrorMessage(dwResult));
    Exit;
  end;
  try
    LsiWork := LShareInfo; // Arbeitsvariable füllen
    for i := 1 to dwEntriesRead do begin // Lieber die tatsächlich gelesenen Einträge nehmen
                                         // auch wenn man  bei MAX_PREFERRED_LENGTH alle
                                         // erwischen sollte
      EnumNetworkStringlist.Add(LsiWork.shi2_netname+', '+LsiWork.shi2_path);
      Inc(LsiWork); // Da der Typ jetzt dem der Struktur entspricht reicht inc
    end;
  finally
    // Hier nicht die Adresse (@) der Variablen übergeben, sondern die
    // durch den Aufruf von NetShareEnum reservierten Buffer, sonst
    // knirscht es ;-)
    // Gilt bei allen Lanmanger Funktionen, die den Buffer selber reservieren
    NetApiBufferFree(LShareInfo);
  end;
end;

[MicMic]

Ich kürze das mal hier ab. Ich glaube diese Zeile macht mir Probleme:

Zitat:

Zitat von Christian Seehase (Beitrag 795462)

Code:

  Inc(LsiWork); // Da der Typ jetzt dem der Struktur entspricht reicht inc

Ich hatte auch mal ähnliches benutzt, wo die Variable mit SizeOf() hochgezählt wurde. Dies ging ebenfalls nicht aber ein Test mit der hälfte (größe div 2) ging dann wiederum. Aber man kann ja nicht (ohne Plan) irgendwas machen ;-)
Ich bekomme jedenfalls immer eine "c0000005 ACCESS_VIOLATION" Meldung angezeigt. Im Debugger wird eine Zeile markiert:

Code:

function _PWCharLen(P: PWideChar): Integer;
{$IFNDEF LEGACY_PWCHARLEN}
begin
  Result := 0;
  if P <> nil then
    while P[Result] <> #0 do   // <- diese hier wird markiert (ist aus der system.pas)
      Inc(Result);
end;

Hier beim schreiben... ich habe den Code gerade mal unter Win32 ausgeführt. Ist mir gerade so eingefallen. Da geht es. Zurück auf Win64 und schon ist der Fehler wieder da. Weiß jemand, wie ich das anpasse, damit es bei 32 sowie auch bei 64 Bit geht?

[Dalai]

@MicMic:
Definiere mal das record nicht als

Delphi-Quellcode:

packed

. Vor einigen Jahren hatte ich auch mit diversen Problemen, vor allem Zugriffsverletzungen, zu kämpfen, als es um Win64 ging. Mit der Entfernung der Anweisung

Delphi-Quellcode:

packed

waren die Zugriffsverletzungen dann verschwunden.

Grüße
Dalai

[MicMic]

Zitat:

Zitat von Dalai (Beitrag 1481072)

@MicMic:
Definiere mal das record nicht als

Delphi-Quellcode:

packed

. Vor einigen Jahren hatte ich auch mit diversen Problemen, vor allem Zugriffsverletzungen, zu kämpfen, als es um Win64 ging. Mit der Entfernung der Anweisung

Delphi-Quellcode:

packed

waren die Zugriffsverletzungen dann verschwunden.

Grüße
Dalai

Ja Super... jetzt geht es mit 32 und 64. Danke
Habe zur Ansicht:
ADMIN$, C$, D$, E$, IPC$ und einen freigegebenen Ordner

Was kann denn da alles so drin stehen?
Noch andere spezielle Sachen? In der "LsiWork.shi2_remark" Variable habe ich bei mir "Remoteverwaltung, Standardfreigabe und Remote-IPC" stehen. Ein freigegebenen Ordner hat bei mir kein Kommentar im "remark" stehen. Frage mich auch gerade wie ich einen hinzugefügten freigegebenen Ordner identifizieren kann. Das Dollarzeichen zu überprüfen, bringt wohl nicht viel, weil ein Ordner selber auch ein "$" Zeichen haben kann.

Mike

[jobo]

Das sind administrative Standardfreigaben. Die kannst Du auch aufheben oder so anschauen: Systemsteuerung> Computerverwaltung> Freigaben.

Du kannst ja selbst neue erzeugen und die sollten dann aufgeführt werden. Wie die genannt werden, ist glaube ich unwichtig.
(Vielleicht keine Fragezeichen oder so, die üblichen Regeln...)

[MicMic]

Zitat:

Zitat von jobo (Beitrag 1481106)

Das sind administrative Standardfreigaben. Die kannst Du auch aufheben oder so anschauen: Systemsteuerung> Computerverwaltung> Freigaben.

Du kannst ja selbst neue erzeugen und die sollten dann aufgeführt werden. Wie die genannt werden, ist glaube ich unwichtig.
(Vielleicht keine Fragezeichen oder so, die üblichen Regeln...)

Mir geht es um eine Liste wie im Explorer, damit der Benutzer in diese freigegebenen Ordner wechseln kann. Diese Standardfreigaben kommen dort nicht zur Ansicht. Das Dollarzeichen zu prüfen, geht leider nicht. Ein Ordner von "ADMIN$" wird dort zwar als Freigabename "ADMIN$2" angelegt aber ein Ordner mit "Hallo$" bekommt als Freigabename dann auch nur "Hallo$" zugewiesen. Somit kann ich leider nicht dieses Dollarzeichen als letzten Zeichen als Überprüfung nutzen. Was ich noch sehe, ist die Beschreibung der Einträge. Diese Standardfreigaben haben einen Kommentar. Auch ein Drucker bekommt mit "print$" einen Kommentar zugewiesen. Dagegen sind normale Ordner (die ich freigeben möchte) ohne Kommentar versehen. Das könnte man als Überprüfung nutzen. Aber denke, dass ist definitiv der falsche Weg.

[MicMic]

Inzwischen habe ich auf "shi2_type" geschaut. Somit kann ich schon mal diese C$,D$,ADMIN$,IPC$ ausblenden lassen (sie haben den Wert "[Disk] und [Special]"). Dagegen haben meine hinzugefügten Ordner nur den Wert "[Disk]". Damit kann man "shi2_type" auswerten lassen.

Delphi-Quellcode:

const
    STYPE_DISKTREE  = 0;
    STYPE_PRINTQ    = 1;
    STYPE_DEVICE    = 2;
    STYPE_IPC       = 3;
    STYPE_TEMPORARY = $40000000;
    STYPE_SPECIAL   = $80000000;

function ShareTypeToStr(SType : DWORD) : String;
begin
    case SType and $FFFF of
    STYPE_DISKTREE:  Result := '[Disk]';
    STYPE_PRINTQ:    Result := '[Printer]';
    STYPE_DEVICE:    Result := '[Device]';
    STYPE_IPC:       Result := '[IPC]';
    else
                     Result := '[Type0x' + IntToHex(SType, 8) + ']';
    end;
    if (SType and STYPE_SPECIAL) <> 0 then
        Result := Result + '[Special]';
    if (STYpe and STYPE_TEMPORARY) <> 0 then
        Result := Result + '[Temporary]';
end;

Leider hat nun ein Drucker (print$) kein "[Special]" dabei. Nur "[Disk]". Dieser Eintrag sollte natürlich auch als nicht hinzugefügten freigegebenen Ordner erkannt werden. Aber ich bin ja schon mal weiter. Ich frage mich auch, was "[Temporary]" sein kann, um damit mal zu testen.

Mir ist das mit dem Netzwerk-Zeugs alles noch etwas unlogisch. Keine Erfahrung damit. Habe auch nur einen PC. Bei der Funktion "NetShareEnum" kann man anstatt "nil" (steht ja für Lokal) auch einen Computernamen angeben. Wie kann ich damit denn mal herumtesten?

[himitsu]

Zitat:

Zitat von MicMic (Beitrag 1481138)

Ich frage mich auch, was "[Temporary]" sein kann, um damit mal zu testen.

Ich würde empfehlen den Hersteller zu fragen, oder Google und Co.
https://docs.microsoft.com/en-us/win...-netsharecheck
https://stackoverflow.com/questions/...type-temporary

Also ein Beispiel dafür wäre ein RAM-Drive, welches z.B. beim Neustart des Rechners den Inhalt vergessen hat.
Bzw. hier ein "temporärer" Share, wäre Einer, welcher beim Neustart weg ist. (ist nur jetzt da, bis zum Ende ... wurde also nicht "permanent" gespeichert)


Welchen Typ ein Share/Drive hat, das bestimmt der Treiber.
Es gibt auch Treiber, die einfach schlecht programmiert sind und falsche Eigenschaften liefern.




PACKED einfach einfach so weglassen, bzw. einfügen, das ist definitiv das falsche Vorgehen.

Ob das PACKED oder sonstwie ausgerichtet ist, dass steht in der Dokumentation, bzw. den Header-Files dieser API.
Im Delphi muß "einfach" nur das gleiche gemacht werden, wie es die Quelle vorschreibt.


Aber ja, grundsätzlich trifft es zu, dass die meisten Records der WinAPI nicht packed sind.
PACKED entspricht {$ALIGN 1}

[MicMic]

Danke für die Info zum STYPE_TEMPORARY
Ja, ist logisch... RAM-Disk.

Ich teste gerade Werte, damit ich z.B. diesen Drucker identifizieren und somit diesen ausschließen kann.
Habe mal direkt als DWORD shi2_type überprüft. Damit komme ich nicht weiter. Gleiche Werte

Ich habe mal das Ganze mit SHARE_INFO_502 probiert. Weil hier gibt es noch shi502_reserved.

Hier stehen die Infos drinnen. Also normale hinzugefügte Ordner haben hier den Wert 128. Ein Drucker den Wert 104. Dagegen ein hinzugefügter Ordner mit Kommentar wiederum 92. Da muss man wohl was ähnliches zusammenbauen wie die Funktion "ShareTypeToStr", damit man am Ende richtig unterscheiden kann. Ich versuche Google zu bemühen. Man weiß ja erst mal nicht was in "shi502_reserved" alles enthalten sein kann.

[MicMic]

Mal zur Info:

Sogar der Explorer prüft auf das Dollarzeichen.
Also Microsoft selbst mach es nicht richtig (sieht zumindest so aus).

Also ein Ordner "hallo$" kann man ganz normal freigeben. NetShareEnum findet diesen auch aber der Explorer zeigt diesen nicht an. Also prüft Microsoft hier wohl auch auf das Dollarzeichen.

Auch Sources von Apple habe ich gefunden. Da wird auf "print$" geprüft. Das ist auch falsch. Wenn es nämlich kein Drucker freigegeben ist, dann kann man einen Ordner mit dem Namen "print$" auch ganz normal benutzen, für eine Freigabe. Nur die Programme werden dann falsch funktionieren.