Ich habe mir 2 kleine Klassen (TStreamServer, TStreamClient) geschmiedet, die den Datenaustausch zwischen 2 Rechnern organisieren sollen. Darin wird jeweils ein TNMStrmServ (zum Empfangen) und ein TNMStrm (zum Senden) verwendet. Soweit so gut, kompilieren klappt fehlerfrei.

Zum austesten habe ich mir ein kleines Testprojekt gebastelt was aber entweder mit der Exception "Connection failed" (NMStrmServ->Listen(false); nicht auskommentiert) abschmiert, oder sich festfährt (NMStrmServ->Listen(false); einkommentiert).

Wo liegt der Fehler?

__fastcall TStreamServer::TStreamServer(TComponent* Owner, int iPort)
{
           NMStrmServ              = new TNMStrmServ(Owner);
           NMStrmServ->Port        = iPort;
           NMStrmServ->ReportLevel = 0;
           NMStrmServ->OnMSG       = NMStrmServMSG;
           NMStrmServ->TimeOut     = 0;
           //NMStrmServ->Listen(false); 
}

__fastcall TStreamServer::~TStreamServer()
{
           if (NMStrmServ) delete NMStrmServ;
}

void __fastcall TStreamServer::NMStrmServMSG(TComponent *Sender, const AnsiString sFrom, TStream *strm)
{
     TStreamHeader Header;
     TMemoryStream *msSendData = NULL;

     TMemoryStream *msIncomingData = new TMemoryStream();
     msIncomingData->CopyFrom(strm, strm->Size);
     msIncomingData->Seek(0, soFromBeginning);

     memset(&Header, 0, sizeof(Header));

     // Header lesen
     msIncomingData->Read(&Header, sizeof(Header));

     // Commando im Stream auswerten
     switch (Header.iCommand)
     {
            // Stream-Anforderung
            case CMD_REQUEST_STREAM   : { break; }
            // Stream-Sendung
            case CMD_DELIVER_STREAM   : { break; }
            default : {}
     }

     if (msIncomingData) delete msIncomingData;
     if (msSendData)     delete msSendData;
}

__fastcall TStreamClient::TStreamClient(TComponent* Owner, AnsiString sHost, AnsiString sFrom, int iPort)
{
           NMStrm              = new TNMStrm(Owner);
           NMStrm->Port        = iPort;
           NMStrm->ReportLevel = 0;
           NMStrm->Host        = sHost;
           NMStrm->FromName    = sFrom;
           NMStrm->TimeOut     = 0;
}

__fastcall TStreamClient::~TStreamClient()
{
           if (NMStrm) delete NMStrm;
}

bool __fastcall TStreamClient::SendCommand(TStreamHeader Header, TStream *Stream)
{
     bool bRetVal = true;
     TMemoryStream *msSendData = NULL;
     TMemoryStream *msStreamData = NULL;

     try
     {
        try
        {
           msSendData = new TMemoryStream();

           // Header schreiben
           msSendData->Write(&Header, sizeof(Header));

           // und evtl. Nutzdaten mitsenden
           if (Stream)
           {
              // zu sendendes TStream-Objekt in Memorystream wandeln
              try
              {
                 msStreamData = new TMemoryStream();

                 msStreamData->CopyFrom(Stream, Stream->Size);
                 msStreamData->Seek(0, soFromBeginning);
                 msStreamData->SaveToStream(msSendData);
              }
              catch ( Exception &E )
              {
                    sLastError = E.Message;
              }
           }

           NMStrm->PostIt(msSendData);
        }
        catch ( Exception &E )
        {
              sLastError = E.Message;
              bRetVal = false;
        }
     }
     __finally
     {
              if (msSendData)   delete msSendData;
              if (msStreamData) delete msStreamData;
     }

     return bRetVal;
}

Hier noch das Testprojekt:

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
           Serv = new TStreamServer(this, 10000);
           Client = new TStreamClient(this, "localhost", "TestClient", 10000);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
     delete Serv;
     delete Client;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
     TStreamHeader Header;
     memset(&Header, 0, sizeof(Header));

     // Header erzeugen
     Header.iCommand = CMD_REQUEST_STREAM;

     // testweise erstmal nur einen Header schicken
     Client->SendCommand(Header, NULL);
}