tcp/ip-verbindung

[markus lemcke]

Hallo,


ich habe einen VMWare-Rechner mit der TCP/IP 192.168.88.33 .
dem möchte ich daten (Strings) schicken

aus dem web habe ich folgenden code, mit der man eine tcp/ip-Verbindung aufbauen können soll:

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class Program
{
   public static void Main(string[] args)
   {
      //Client
//      Console.WriteLine("Client");

//      IPAddress ipadr = IPAddress.Parse("127.0.0.1");
      IPAddress ipadr = IPAddress.Parse("192.168.88.33");

      TcpListener tcpListener = new TcpListener(ipadr, 5001);
      tcpListener.Start();
      Socket socket = tcpListener.AcceptSocket();

      if (socket.Connected)
      {
         Console.WriteLine("Connected");

         NetworkStream ns = new NetworkStream(socket);

         StreamWriter sw = new System.IO.StreamWriter(ns);

         StreamReader sr = new System.IO.StreamReader(ns);

         string data = "Data over Network form Client";
         string data2 = "Markus: Hallo Server!";   //Von Markus

         //sw.WriteLine(data);
         sw.WriteLine(data2);

         sw.Flush();
         //data = sr.ReadLine();
         data2 = sr.ReadLine();

         //Console.WriteLine(data);         
         Console.WriteLine(data2);

         sr.Close();
         ns.Close();
         sw.Close();
      }

      socket.Close();

      Console.ReadLine();
   }
}

Beim Starten vom tcpListener bekomme ich diese Fehlermeldung:

System.Net.Sockets.SocketException wurde nicht behandelt.
Message="Die angeforderte Adresse ist in diesem Kontext ungültig"
Source="System"
ErrorCode=10049
NativeErrorCode=10049
StackTrace:
bei System.Net.Sockets.Socket.DoBind(EndPoint endPointSnapshot, SocketAddress socketAddress)
bei System.Net.Sockets.Socket.Bind(EndPoint localEP)
bei System.Net.Sockets.TcpListener.Start(Int32 backlog)
bei System.Net.Sockets.TcpListener.Start()
bei Program.Main(String[] args) in E:\C#\IPTest\Program.cs:Zeile 18.
bei System.AppDomain._nExecuteAssembly(Assembly assembly, String[] args)
bei System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
bei Microsoft.VisualStudio.HostingProcess.HostProc.Run UsersAssembly()
bei System.Threading.ThreadHelper.ThreadStart_Context( Object state)
bei System.Threading.ExecutionContext.Run(ExecutionCon text executionContext, ContextCallback callback, Object state)
bei System.Threading.ThreadHelper.ThreadStart()
InnerException:

Was bedeutet das?
was läuft hier schief und was tue ich dagegen?

[Ralf Jansen]

Was passiert wenn du denTcpListener nur mit PortNummer erzeugst?

Deine VM wird ja eh nur einen simulierten Netzwerkadapter haben oder? Da solltest du die IP weglassen können.

[markus lemcke]

Hallo,

ohne Portnummer kommt beim erstellen des Projekts diese Fehlermeldung:

Warnung	1	Ungültiger Suchpfad "E:\Programme\Microsoft Visual Studio\VC98\mfc\lib" in "LIB-Umgebungsvariable" -- "Das System kann den angegebenen Pfad nicht finden. ".	NetworkStreamSample

was ist eine LIB-Umgebungsvariable?
Di fehlermeldung habe ich heute schon paar mal gehabt!

an der ip-adresse kann es meiner nicht liegen.
ich von meinem "nicht virtuellen" rechner den virtuellen rechner unter der ip anpingen!!!

[Ralf Jansen]

ohne Portnummer kommt beim erstellen des Projekts diese Fehlermeldung:

Ich meinte nicht ohne Port sondern nur Port. Lass die IP mal weg auch wenn das die richtige IP der VM ist.

[markus lemcke]

das ding war der komplett falsche ansatz!
man braucht den TcpClient serverSocket = new TcpClient();!!!

dann geht es!

[markus lemcke]

hallo,

habe inwzischen es geschafft ein dos-client und einen dos-server zu entwickeln.
der client schickt sein daten so:

Byte[] vByteMessage = new byte[1000];
............

Console.WriteLine("Verbindung mit Server erfolgreich!");
//daten werden in C# in Form eines Streams gesendet. Wie bei Java!
NetworkStream ns = serverSocket.GetStream();
StreamReader sr = new StreamReader(ns);
StreamWriter sw = new StreamWriter(ns);

try
{ 
ns.Write(vByteMessage, 0, vPacketS.TotalLength);
}

Der Server empfängt die Daten so:

NetworkStream vNS = new NetworkStream(vsocket);
StreamReader vSR = new StreamReader(vNS);
StreamWriter vSW = new StreamWriter(vNS);

EmpfangsLength = vSR.ReadBlock(vByteMessage, 0, 1000);

jetzt möchte ich, dass der Server als Bestätigung, dass er die Daten(vByteMessage) erhalten hat,wieder an den client zurückschickt in dem Format wie er sie empfangen hat.

welchen Stream, mit welcher write-methode muss ich verwenden?

[markus lemcke]

ich glaube ich poste mal den ganzen code!

das ist der server:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace NetworkServer
{
    class Program
    {
        //**********************************************************************
        //*                             S e r v e r                            *
        //**********************************************************************


        static void Main(string[] args)
        {
          char[] vByteMessage = new char[1000];
          int EmpfangsLength;
          string AnzeigeString;
start:
          //TcpListener listener = new TcpListener(IPAddress.Parse("192.168.2.12"), 8000);
          TcpListener listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 8000);
          listener.Start();
          Console.WriteLine("Server wartet auf Nachricht ...");
         
          // Verbindungsanforderungen werden jetzt überwacht
          Socket vsocket = listener.AcceptSocket();
          if (vsocket.Connected)
          {
              NetworkStream vNS = new NetworkStream(vsocket);
              StreamReader vSR = new StreamReader(vNS);
              StreamWriter vSW = new StreamWriter(vNS);    
              EmpfangsLength = vSR.ReadBlock(vByteMessage, 0, 1000);
              AnzeigeString = "";
              for (int i = 0; i < EmpfangsLength; i++)
              {   int value = vByteMessage[i];
                  AnzeigeString += "0x" + value.ToString("x") + " ";
              }

             // Console.WriteLine(vByteMessage);
              Console.WriteLine(AnzeigeString);
              vSW.Write(vByteMessage, 0, EmpfangsLength);
              Console.ReadLine();

              vNS.Close();
              vSR.Close();
              vsocket.Close();
          }
          Console.ReadLine();
          goto start;
        }
    }
}

das ist der Client:

using System;
using System.Runtime.InteropServices;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Security.Permissions;
using System.Text;


public class Program
{
    //**********************************************************************
    //*                             C l i e n t                            *
    //**********************************************************************

    struct Message_Type
    {
        public int vPacketType;
        public int Type_ID;
    }


    [StructLayout(LayoutKind.Sequential)]
    public struct _PacketStructure
    {
        public Int32 TotalLength;
        public Int32 HeaderLength;
        public Int32 Version;
        public Byte Engine;
        public Byte PacketType;
        public Byte TypeID;
//        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 500)]
//        public Byte[] PayLoad;
    }

    Byte[] TXBuffer = new Byte[100];
    

    //Methode kopiert die Struktur in ein ByteArray
    public static byte[] MakeBinary(_PacketStructure ps)
    {
        byte[] result = new byte[100];
        Array.Copy(BitConverter.GetBytes(ps.TotalLength), 0, result, 0, 4);
        Array.Copy(BitConverter.GetBytes(ps.HeaderLength), 0, result, 4, 4);
        Array.Copy(BitConverter.GetBytes(ps.Version), 0, result, 8, 4);
        Array.Copy(BitConverter.GetBytes(ps.Engine), 0, result, 12, 1);
        // usw.usf.
        return result;
    }

    //Wandelt einen String mit zahlen in hex um
    public static string strtostrhex(string vstr)
    {
        string vOrg;
        vOrg = "@"+vstr;
        vstr = "";
        for (int i = 0; i < vOrg.Length; i++)
        {
            int value = vOrg[i];
            vstr += "0x" + value.ToString("x") + " ";

        }
        return(vstr);
    }


   public static void Main(string[] args)
   {
       string vErg;
       Message_Type vMessageT = new Message_Type();
       Byte[] vByte = new byte[100];
       Byte[] vByteMessage = new byte[1000];
       char[] vByteMessageEmpfang = new char[1000];
       Byte[] PayLoad = new byte[1000];
       int PayLoadLength;
       int EmpfangsLength;
       string AnzeigeString;
       

       //*********************************************************
       //* Daten in Hex umwandeln und in vErg speichern          *
       //*********************************************************

       //***********Versionsnummer********************************
       vMessageT.vPacketType = 0x01;
       vMessageT.Type_ID = 0;

       //MessageType in Hex konvertieren
       vErg = strtostrhex(vMessageT.vPacketType.ToString());
       vErg += "0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00";
       vErg += strtostrhex(vMessageT.Type_ID.ToString());

       //*********************************************************

       
       //Console.WriteLine(vErg);
      // Console.ReadLine();
       //return;

       _PacketStructure vPacketS = new _PacketStructure();
       vPacketS.HeaderLength = 15;
       vPacketS.Version = 1;
       vPacketS.Engine = 0;

       vPacketS.PacketType = 0x02;
       vPacketS.TypeID = 0x01;

       PayLoad[0] = 0;
       PayLoad[1] = 0;
       PayLoad[2] = 0;
       PayLoad[3] = 0;
       PayLoad[4] = 0;
       PayLoad[5] = 0;
       PayLoad[6] = 0;
       PayLoad[7] = 0;
       PayLoad[8] = 0;
       
       PayLoadLength = 9;

       vPacketS.TotalLength = vPacketS.HeaderLength + PayLoadLength;

       Array.Copy(BitConverter.GetBytes(vPacketS.TotalLength), 0, vByteMessage, 0, 4);
       Array.Copy(BitConverter.GetBytes(vPacketS.HeaderLength), 0, vByteMessage, 4, 4);
       Array.Copy(BitConverter.GetBytes(vPacketS.Version), 0, vByteMessage, 8, 4);
       Array.Copy(BitConverter.GetBytes(vPacketS.Engine), 0, vByteMessage, 12, 1);
       Array.Copy(BitConverter.GetBytes(vPacketS.PacketType), 0, vByteMessage, 13, 1);
       Array.Copy(BitConverter.GetBytes(vPacketS.TypeID), 0, vByteMessage, 14, 1);
       Array.Copy(PayLoad, 0, vByteMessage, 15, PayLoadLength);
      
       
      Console.WriteLine("Versuche mich mit Server zu verbinden...");
     //Die Klasse TcPClient Stellt Clientverbindungen für TCP-Netzwerkdienste bereit.
       TcpClient serverSocket = new TcpClient();
       int vFehler = 0;

       try
       {   //Versuch sich mit der IP-Adresse zu Verbinden
           //serverSocket.Connect("192.168.88.33", 5001);
           serverSocket.Connect("127.0.0.1", 8000);
       }
       catch (SocketException ex) //die SocketException findet man in der Doku
       {   //wenn das Verbinden nicht geklappt hat geht es hier weiter 
           vFehler = ex.ErrorCode;
           Console.WriteLine("Server nicht vorhanden!");
           Console.ReadLine();
       }

       if (vFehler != 0)
           return;
       else

           if (vFehler == 0)
           {
               Console.WriteLine("Verbindung mit Server erfolgreich!");
               //daten werden in C# in Form eines Streams gesendet. Wie bei Java!
               NetworkStream ns = serverSocket.GetStream();
               StreamReader sr = new StreamReader(ns);
               StreamWriter sw = new StreamWriter(ns);

               try
               {   
                   ns.Write(vByteMessage, 0, vPacketS.TotalLength);
               }
               //Flush() löscht sämtliche Puffer für den aktuellen Writer und veranlasst die 
               //Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream.
               finally
               {
                   sw.Flush();
                   sw.Close();
                   ns.Close();
                   Console.ReadLine();
               }
           }

       //*********************************************************
       //*                Listener erzeugen                      *
       //*********************************************************

       TcpListener listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 8001);
       listener.Start();

       // Verbindungsanforderungen werden jetzt überwacht
       Socket vsocket = listener.AcceptSocket();
       if (vsocket.Connected)
       {
           NetworkStream vNS = new NetworkStream(vsocket);
           StreamReader vSR = new StreamReader(vNS);
           StreamWriter vSW = new StreamWriter(vNS);
           EmpfangsLength = vSR.ReadBlock(vByteMessageEmpfang, 0, 1000);
           AnzeigeString = "";
           for (int i = 0; i < EmpfangsLength; i++)
           {
               int value = vByteMessageEmpfang[i];
               AnzeigeString += "0x" + value.ToString("x") + " ";
           }

           // Console.WriteLine(vByteMessage);
           Console.WriteLine("Antwort Server: " + AnzeigeString);
           // vSW.Write(vByteMessage, 0, EmpfangsLength);
           Console.ReadLine();

           vNS.Close();
           vSR.Close();
           vsocket.Close();
       }


   }
}

das ding funzt bis jetzt soweit, dass der server vom client daten bekommt und diese bei sich auf der Console anzeigt. jetzt möchte ich aber, dass der Server genau die gleichen daten an den client zurückschickt und der client die empfangenen daten auf der console anzeigt. hierfür habe ich dem client einen listener hinzugefügt, aber es funzt noch nicht!
weiss jemand warum?