TCP-Verbindung C -> VB.Net

    TCP-Verbindung C -> VB.Net

    Hi,
    Ich habe einen TCP-Server mit C geschrieben. Der läuft auf einem Debian-System.
    Als Client habe ich ein VB.Net-Programm.

    Ich kann mit dem Client zum Server connecten und auch Daten senden.
    Jedoch kann ich die Daten die vom Server kommen nicht auslesen.

    Hier die Codes:

    Server: (C)
    Spoiler anzeigen

    C-Quellcode

    1. #include <unistd.h>
    2. #include <stdlib.h>
    3. #include <stdio.h>
    4. #include <sys/socket.h>
    5. #include <netinet/in.h>
    6. #include <strings.h>
    7. #include <string.h>
    8. #include <arpa/inet.h>
    9. #include <pthread.h>
    10. #include <errno.h>
    12. #define ZEILENLAENGE 10
    14. pthread_t thread_counter_get, thread_counter_set;
    15. char *ptr, *ptr_counter_get, ptr_counter_set;
    16. char buffer[20], buffer_temp[20], puffer[ZEILENLAENGE];
    17. char *ar_counter_set[1];
    18. int x, iMinuten, connected = 0, csd;
    19. FILE *quelle;
    21. void *func_counter_get (void* p) { // Der Type ist wichtig: void* als Parameter und Rückgabe
    23. if( (quelle=fopen("counter.txt","r")) == NULL) { // Versuchen Datei zu öffnen
    24. fprintf(stderr, "Kann Datei nicht oeffnen\n"); // Lesen Fehlerhaft
    25. return EXIT_FAILURE;
    26. } // Lesen Fehlerfrei
    28. fgets(puffer, ZEILENLAENGE, quelle);
    29. fclose(quelle);
    30. iMinuten=puffer;
    31. printf("counter=%s\n",iMinuten);
    34. /*return EXIT_SUCCESS;
    35. */
    36. //return NULL; // oder in C++: return 0;// Damit kann man Werte zurückgeben
    37. }
    39. void *func_counter_set (void* p) { // Der Type ist wichtig: void* als Parameter und Rückgabe
    40. printf("test1234\n");
    41. /*
    42. x = 0;
    43. ptr_counter_set = strtok(buffer_temp, ";"); // buffer_temp bei ; trennen und in ptr schreiben
    44. while(ptr_counter_set != NULL) {
    46. ar_counter_set[x]=ptr_counter_set;
    47. //printf("Hier: %s\n",ueberschuss_counter_get[x]);
    48. x++;
    49. ptr_counter_set = strtok(NULL, ";"); // naechsten Abschnitt erstellen
    50. }
    55. return NULL; // oder in C++: return 0;// Damit kann man Werte zurückgeben
    56. */
    57. }
    59. void Eth_Send_Recv_Data()
    60. {
    61. //printf("punkt1\n");
    62. while(connected)
    63. {
    64. // Vom Client lesen und ausgeben
    65. memset(buffer, 0, sizeof(buffer));
    66. int bytes = recv(csd, buffer, sizeof(buffer), 0);
    68. if (bytes == 0 || bytes == -1 ){
    69. //csd=0;
    70. connected=0;
    71. printf("Client getrennt!\n");
    73. } else {
    74. //printf("Der Client hat folgenden String gesendet: %s\n", buffer);
    75. //printf("Es wurden %d Bytes empfangen\n", bytes);
    77. //Empfangene Daten verarbeiten
    78. sprintf(buffer_temp,"%s",buffer);
    79. ptr = strtok(buffer, ";"); // string bei ; trennen und in ptr schreiben
    81. //if (strcmp(ptr, "counter_get") != 0) {
    82. if (strstr(ptr, "counter_get") !=NULL ) {
    83. //printf("getcounter\n");
    84. pthread_create(&thread_counter_get, NULL, func_counter_get, NULL); // Thread aufrufen
    85. pthread_join (thread_counter_get, NULL); // Auf Threadende warten
    86. //printf("getcounter2\n-------------------\n");
    87. } else if (strstr(ptr, "counter_set") !=NULL ) {
    88. //printf("setcounter1\n");
    89. pthread_create(&thread_counter_set, NULL, func_counter_set, NULL);
    90. pthread_join (thread_counter_set, NULL);
    91. //printf("setcounter2\n-------------------\n");
    92. } else {
    93. //printf("andere\n");
    94. }
    95. }
    96. }
    97. }
    99. int main(void) {
    102. /* Server-Anfang */
    103. /* Socket erstellen - TCP, IPv4, keine Optionen */
    104. int lsd = socket(AF_INET, SOCK_STREAM, 0);
    106. /* IPv4, Port: 50125, jede IP-Adresse akzeptieren */
    107. struct sockaddr_in saddr;
    108. saddr.sin_family = AF_INET;
    109. saddr.sin_port = htons(50125);
    110. saddr.sin_addr.s_addr = htons(INADDR_ANY);
    112. /* Socket an Port binden */
    113. bind(lsd, (struct sockaddr*) &saddr, sizeof(saddr));
    115. /* Auf Socket horchen (Listen) */
    116. listen(lsd, 20);
    118. /* Puffer und Strukturen anlegen */
    119. struct sockaddr_in clientaddr;
    121. bzero(buffer, sizeof(buffer));
    124. while(1) {
    126. /* Auf Verbindung warten, bei Verbindung Connected-Socket erstellen */
    127. socklen_t clen = sizeof(clientaddr);
    128. csd = accept(lsd, (struct sockaddr*) &clientaddr, &clen);
    130. if (csd == -1) {
    131. perror("Fehler bei accept()\n" );
    132. printf("Errno Code:\t%d\n",errno);
    133. } else {
    134. connected=1;
    135. printf("Client verbunden!\n");
    136. Eth_Send_Recv_Data();
    137. }
    138. }
    139. }



    Client: (VB.Net)
    Spoiler anzeigen
    Private Sub Connect(ByVal server As String, ByVal message As String)

    VB.NET-Quellcode

    1. Try
    2. ' Create a TcpClient.
    3. ' Note, for this client to work you need to have a TcpServer
    4. ' connected to the same address as specified by the server, port
    5. ' combination.
    6. Dim port As Int32 = 50125
    7. Dim client As New TcpClient(server, port)
    9. ' Translate the passed message into ASCII and store it as a Byte array.
    10. Dim data As Byte() = System.Text.Encoding.ASCII.GetBytes(message)
    12. ' Get a client stream for reading and writing.
    13. ' Stream stream = client.GetStream();
    14. Dim stream As NetworkStream = client.GetStream()
    16. ' Send the message to the connected TcpServer.
    17. stream.Write(data, 0, data.Length)
    19. Console.WriteLine("Sent: {0}", message)
    21. ' Receive the TcpServer.response.
    22. ' Buffer to store the response bytes.
    23. data = New Byte(256) {}
    25. ' String to store the response ASCII representation.
    26. Dim responseData As String = String.Empty
    28. ' Read the first batch of the TcpServer response bytes.
    29. Dim bytes As Int32 = stream.Read(data, 0, data.Length)
    30. responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes)
    31. Console.WriteLine("Received: {0}", responseData)
    33. ' Close everything.
    34. stream.Close()
    35. client.Close()
    36. Catch e As ArgumentNullException
    37. Console.WriteLine("ArgumentNullException: {0}", e)
    38. Catch e As SocketException
    39. Console.WriteLine("SocketException: {0}", e)
    40. End Try
    42. Console.WriteLine(ControlChars.Cr + " Press Enter to continue...")
    43. Console.Read()
    44. End Sub 'Connect



    Nachdem ich connected habe, sende ich z.B. ein counter_get an den Server. Dieser verarbeitet das und gibt den Inhalt einer Datei aus.
    Soweit in Ordnung. Der Client läuft, bis zu Zeile 29:

    Quellcode

    1. Dim bytes As Int32 = stream.Read(data, 0, data.Length)

    Hier hängt sich das Programm dann auf, bis der Server wieder geschlossen wird.

    Hat von euch jemand eine Ahnung, woran das liegen kann?
    Sendet der Server die Daten falsch raus? Fehlt beim Client noch was?

    Viele Danke für die Hilfe...
    wintoolz.de
    • wintoolz.KeyLocker - Programm zum sicheren Verwalten von Passwörten
    • wintoolz.CodeGallery - Datenbank für Codebeispiele veschiedener Programmiersprachen
    • wintoolz.Haushaltsbuch - Dient zum Auflisten der Aktivitäten ihrer Bankkonten

    Benutze auch du Ecosia

Facebook
Telefonspende