Senden an Named Pipe klappt nicht! Warum? [erledigt]

[DualCoreCpu]

Hallo,

Ich experimentiere soeben mit Named Pipes.

Leider klappt die Datenübertragung nicht und ich habe keine Ahnung, wo ich meinen Fehler suchen müsste. Wer kann mir helfen.

Hier erst mal mein Quelltext:

Delphi-Quellcode:

//Hier erst mal der Pipe-Server, den ich später mit Kommandos steuern will.
program PipedProcess;

uses
  Sysutils,
  {$ifdef WIN32}
  Windows
  {$else}
   {$ifdef LINUX}
    libc, linux
   {$endif}
   
  {$endif}
  ;

{$APPTYPE CONSOLE}

const 
  BytePipe     = PIPE_TYPE_BYTE or PIPE_READMODE_BYTE; 
  MessagePipe  = PIPE_TYPE_MESSAGE or PIPE_READMODE_MESSAGE;

  ONE_INSTANCE = 1;
  MAX_INSTANCE = PIPE_UNLIMITED_INSTANCES;

  PIPE_NAME    = '\\.\pipe\testpipe';

type
  PInputBuffer = ^TInputBuffer;
  TInputBuffer = record
    Signature: String[7];
    Value: Longint;
  end;

var
  Hpipe: THandle;
  lpPipeName: PChar;
  OpenMode: DWord;
  PipeMode: DWord;
  MaxInstances: DWord;
  OutBufSize: DWord;
  InpBufSize: DWord;
  Buffer: TInputBuffer;
  BufferPtr: PInputBuffer;
  Readed: Boolean;
  WasReaded: DWord;
  Written: DWord;
  AOverlapped: POverlapped;

begin
  MaxInstances := 1;
  Readed := false;
  HPipe := CreateNamedPipe('\\.\pipe\testpipe',
     PIPE_ACCESS_DUPLEX {or FILE_FLAG_OVERLAPPED},
      PIPE_TYPE_BYTE or PIPE_READMODE_BYTE or PIPE_WAIT,
      1,                                                    //max instances of this pipe
     SizeOf(Buffer),
     SizeOf(Buffer),
      0,                                                    //if 0 -> 50ms else X ms
     nil
    );
  Getmem(AOverlapped, Sizeof(_OVERLAPPED));
  FillChar(AOverlapped^, Sizeof(_OVERLAPPED), $00);

  ConnectNamedPipe(HPipe, AOverlapped);

  Getmem(Bufferptr, Sizeof(Buffer));
  BufferPtr^.Signature := '';
  BufferPtr.Value := 0;
  repeat
    {if not readed then} ReadFile(HPipe, Buffer, Sizeof(Buffer), WasReaded, nil);  //nil statt AOverlapped
    BufferPtr := @Buffer;
    Readed := true;
    case Buffer.Value of
     1: begin
          WriteFile(HPipe, BufferPtr, Sizeof(Buffer), Written, nil); //nil statt AOverlapped
          write(BufferPtr^.Value); Write('  '); Write(BufferPtr^.Signature); Write('  ');
        end;
     2: Readed := false;
     3: ;
    end;
  until Buffer.Signature = '1234567';
  Freemem(Bufferptr, Sizeof(Buffer));
  Freemem(AOverlapped, Sizeof(_OVERLAPPED));
  CloseHandle(HPipe);
end.
//=============================================================================================
//=============================================================================================

//Und hier der Pipe-Client, von dem aus die Steuerung erfolgt:

unit CodeTemplates;

interface

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

const
  BytePipe     = PIPE_TYPE_BYTE or PIPE_READMODE_BYTE;
  MessagePipe  = PIPE_TYPE_MESSAGE or PIPE_READMODE_MESSAGE;

  ONE_INSTANCE = 1;
  MAX_INSTANCE = PIPE_UNLIMITED_INSTANCES;

  PIPE_NAME    = '\\.\pipe\testpipe';

type
  PInputBuffer = ^TInputBuffer;
  TInputBuffer = record
    Signature: String[7];
    Value: Longint;
  end;

  TPipeForm = class(TForm)
    edCmd: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    edValue: TEdit;
    btnTransfer: TButton;
    Label3: TLabel;
    lblReceive: TLabel;
    lblValue: TLabel;
    procedure FormDestroy(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure btnTransferClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  PipeForm: TPipeForm;
  HPipe: THandle;
  lpPipeName: PChar;
  OpenMode: DWord;
  PipeMode: DWord;
  MaxInstances: DWord;
  OutBufSize: DWord;
  InpBufSize: DWord;
  Buffer: TInputBuffer;
  BufferPtr: PInputBuffer;
  Readed: Boolean;
  WasReaded: DWord;
  Written: DWord;
  AOverlapped: POverlapped;

implementation

{$R *.dfm}


procedure TPipeForm.FormDestroy(Sender: TObject);
begin

  Freemem(AOverlapped, Sizeof(_OVERLAPPED));
end;

procedure TPipeForm.FormCreate(Sender: TObject);
var
   FSA : SECURITY_ATTRIBUTES;
   FSD : SECURITY_DESCRIPTOR;
begin
  InitializeSecurityDescriptor(@FSD, SECURITY_DESCRIPTOR_REVISION);
  SetSecurityDescriptorDacl(@FSD, True, nil, False);
  FSA.lpSecurityDescriptor := @FSD;
  FSA.nLength := sizeof(SECURITY_ATTRIBUTES);
  FSA.bInheritHandle := True;
  HPipe := CreateFile(PChar('\\.\pipe\testpipe'),
                     GENERIC_READ or GENERIC_WRITE,
                     0,
                     @FSA,
                     OPEN_EXISTING,
                     0,
                     0);

  Getmem(AOverlapped, Sizeof(_OVERLAPPED));
  FillChar(AOverlapped^, Sizeof(_OVERLAPPED), $00);

end;

procedure TPipeForm.btnTransferClick(Sender: TObject);
var receive: Boolean; dw,dr: DWord;
begin
  Buffer.Signature := edCmd.Text;
  Buffer.Value     := StrToInt(edValue.Text);
  receive          := (Buffer.Value = 1);


  WriteFile(HPipe, Buffer, SizeOf(Buffer), dw, nil);

  if receive then
  begin
    ReadFile(HPipe, Buffer, SizeOf(Buffer), dr, nil);
  end;
  lblReceive.Caption := Buffer.Signature;
  lblValue.Caption := IntToStr(Buffer.Value);
end;

end.

In einer späteren praktischen Anwendung würde ich den Pipeserver vom Client aus vorher starten.
Hier habe ich ihn vor Start meines Pipeclients gestartet. Ich habe darauf vertraut, das der Name der Pipe irgendwo in Windows eingetragen ist und so auch gefunden wird.

Ich will die hier entwickelte Lösung später, wenn alles nach Wunsch läuft, für die Kommunikation von Programmen verschiedener Programmiersprachen oder Sprachdialekte verwenden, weshalb ich mich dabei bewusst auf das Windows API beschränke, in der Hoffnung, so die portabelste Lösung innerhalb der Windows Plattform für die unterschiedlichen Programmiersprachen zu erhalten.

Was muss ich hier anders machen, damit die Kommunikattion gelingt. Mein Server sollte wenigstens, wenn ich den Wert 1 übegebe, eine 1 auf der Windows Console ausgeben.

Wie kann ich später die Console unsichtbar machen. Die brauche ich ausschließlich für den Test und die Entwicklung meiner Lösung.