Winsock: sending data between two PCs

Hi, I try to send Data between two PCs by using Winsock.
I already got it to send a text the client typed in the console to the server, display it in the console of the server, get a reply typed in the console of the server, back to the client and display it there.
Now I want to get this working for several times. I tried using a endless While but it didn't work. Does anyone know what I did wrong or has a better solution?

Server-Code(endless while from l. 91-143):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

#undef UNICODE

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>


#include <iostream>
#include <string>


// Need to link with Ws2_32.lib
#pragma comment (lib, "Ws2_32.lib")
// #pragma comment (lib, "Mswsock.lib")

#define DEFAULT_BUFLEN 512
#define DEFAULT_PORT "27015"

int __cdecl main(void)
{
    WSADATA wsaData;
    int iResult;

    SOCKET ListenSocket = INVALID_SOCKET;
    SOCKET ClientSocket = INVALID_SOCKET;

    struct addrinfo *result = NULL;
    struct addrinfo hints;

    int iSendResult;
    char recvbuf[DEFAULT_BUFLEN];
    char *sendbuf = "";

    int recvbuflen = DEFAULT_BUFLEN;

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }

    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;

    // Resolve the server address and port
    iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
    if ( iResult != 0 ) {
        printf("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 1;
    }

    // Create a SOCKET for connecting to server
    ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (ListenSocket == INVALID_SOCKET) {
        printf("socket failed with error: %ld\n", WSAGetLastError());
        freeaddrinfo(result);
        WSACleanup();
        return 1;
    }

    // Setup the TCP listening socket
    iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
    if (iResult == SOCKET_ERROR) {
        printf("bind failed with error: %d\n", WSAGetLastError());
        freeaddrinfo(result);
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    freeaddrinfo(result);

    iResult = listen(ListenSocket, SOMAXCONN);
    if (iResult == SOCKET_ERROR) {
        printf("listen failed with error: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    while(1){           //endless while

    // Accept a client socket
    ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
        printf("accept failed with error: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    // No longer need server socket
    closesocket(ListenSocket);


            // Receive until the peer shuts down the connection
            do {

                iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
                if (iResult > 0) {
                    printf("Bytes received: %d\n", iResult);
                    printf("Received: %s\n", recvbuf);
                    std::string srecvbuf(recvbuf , recvbuf + iResult);
                    std::cout <<"Processed:" << srecvbuf <<"\n";

                // Echo the buffer back to the sender
                    std::string teststr;

                    std::cout << "Type the message\n";
                    std::getline(std::cin , teststr);//std::cin >> teststr
                    sendbuf = const_cast<char *> (teststr.c_str());
                    std::cout << "Sending: " << sendbuf << "\n";

                    iSendResult = send( ClientSocket, sendbuf, (int)strlen(sendbuf), 0 );//    //urspr√ľngl.:  send( ClientSocket, recvbuf , iResult, 0 );
                    if (iSendResult == SOCKET_ERROR) {
                        printf("send failed with error: %d\n", WSAGetLastError());
                        closesocket(ClientSocket);
                        WSACleanup();
                        return 1;
                    }
                    printf("Bytes sent: %d\n", iSendResult);
                }
                else if (iResult == 0)
                    printf("Connection closing...\n");
                else  {
                    printf("recv failed with error: %d\n", WSAGetLastError());
                    closesocket(ClientSocket);
                    WSACleanup();
                    return 1;
                }

            } while (iResult > 0);
    }           //endless while

    // shutdown the connection since we're done
    iResult = shutdown(ClientSocket, SD_SEND);
    if (iResult == SOCKET_ERROR) {
        printf("shutdown failed with error: %d\n", WSAGetLastError());
        closesocket(ClientSocket);
        WSACleanup();
        return 1;
    }


    // cleanup
    closesocket(ClientSocket);
    WSACleanup();
    system("PAUSE");
    return 0;
}


Client-Code(endless while from l. 70-135):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <string>


// Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
#pragma comment (lib, "Ws2_32.lib")
#pragma comment (lib, "Mswsock.lib")
#pragma comment (lib, "AdvApi32.lib")


#define DEFAULT_BUFLEN 512
#define DEFAULT_PORT "27015"

int __cdecl main(int argc, char **argv)
{
    WSADATA wsaData;
    SOCKET ConnectSocket = INVALID_SOCKET;
    struct addrinfo *result = NULL,
                    *ptr = NULL,
                    hints;
    char *sendbuf = "Hello world";
    char recvbuf[DEFAULT_BUFLEN];
    int iResult;
    int recvbuflen = DEFAULT_BUFLEN;

    // Validate the parameters
    if (argc != 2) {
        printf("usage: %s server-name\n", argv[0]);
        return 1;
    }  //test

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }

    ZeroMemory( &hints, sizeof(hints) );
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    // Resolve the server address and port
    iResult = getaddrinfo(argv[1], DEFAULT_PORT, &hints, &result);          //urspr√ľngl.:  getaddrinfo(argv[1],
    if ( iResult != 0 ) {
        printf("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 1;
    }


    while(1){               //endless while

    // Attempt to connect to an address until one succeeds
    for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) {

        // Create a SOCKET for connecting to server
        ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype,ptr->ai_protocol);
        if (ConnectSocket == INVALID_SOCKET) {    //Fehlermeldeung
            printf("socket failed with error: %ld\n", WSAGetLastError());
            WSACleanup();
            return 1;
        }


        // Connect to server.
        iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
        if (iResult == SOCKET_ERROR) {
            closesocket(ConnectSocket);
            ConnectSocket = INVALID_SOCKET;
            continue;
        }
        break;
    }

    freeaddrinfo(result);

    if (ConnectSocket == INVALID_SOCKET) {
        printf("Unable to connect to server!\n");
        WSACleanup();
        return 1;
    }


            std::string teststr;

            std::cout << "Type the message\n";
            std::getline(std::cin , teststr);//std::cin >> teststr
            sendbuf = const_cast<char *> (teststr.c_str());
            std::cout << "Sending: " << sendbuf<< "\n";

            // Send an initial buffer
            iResult = send( ConnectSocket, sendbuf, (int)strlen(sendbuf), 0 );
            if (iResult == SOCKET_ERROR) {
                printf("send failed with error: %d\n", WSAGetLastError());
                closesocket(ConnectSocket);
                WSACleanup();
                return 1;
            }

            printf("Bytes Sent: %ld\n", iResult);

            // shutdown the connection since no more data will be sent
            iResult = shutdown(ConnectSocket, SD_SEND);
            if (iResult == SOCKET_ERROR) {
                printf("shutdown failed with error: %d\n", WSAGetLastError());
                closesocket(ConnectSocket);
                WSACleanup();
                return 1;
            }

            // Receive until the peer closes the connection
            do {

                iResult = recv(ConnectSocket, recvbuf, recvbuflen, 0);
                if ( iResult > 0 ){
                                printf("Bytes received: %d\n", iResult);
                                printf("Received: %s\n", recvbuf);
                                std::string srecvbuf(recvbuf , recvbuf + iResult);
                                std::cout <<"Processed:" << srecvbuf <<"\n";
                                }
                else if ( iResult == 0 )
                    printf("Connection closed\n");
                else
                    printf("recv failed with error: %d\n", WSAGetLastError());

            } while( iResult > 0 );

    }           //endless while

    // cleanup
    closesocket(ConnectSocket);
    WSACleanup();
    system("PAUSE");
    return 0;
}
Last edited on
Now I want to get this working for several times.

What exactly do you want to happen? Do you want the server to be called again and again by clients or do you want the client/server to echo back and forth some fixed number of times?
I want get some kind of chat-program.
To get this working you should first check wether or not you've received any data on the open socket.

to do this i recommend you making use of fd_set

http://msdn.microsoft.com/en-us/library/windows/desktop/ms737873(v=vs.85).aspx

I want get some kind of chat-program.
Well, you need some kind of supporting logic beyond echoing a message between client and server.

So you need to think about how the clients connect. What do the clients do and what must the server do?

Then you need to think what's involved in maintaining a conversation between the clients.

And of course, you need to think about clean shutdown.
@vetsyt: I recieved data, as I said in the top it's working once, but after that it doesn't.
@kbw: I know there is no clean shutdown in my code, this doesn't matter now. I only want to know what I did wrong or if there is a better way to do it.
I agree, you don't need to worry about shutdown. But you don't seem to have much in your code that supports a chat application. You've proved you can do the comms, now you need to design and build an application; and it's that's the part you're lacking in.

Forget the code for a while and just think about what you need to do. Back to my earlier post, you need to think about these:
1. So you need to think about how the clients connect.
2. What do the clients do and what must the server do?
3. What's involved in maintaining a conversation between the clients?

Just to get you started, let's go thru a scenario. Connecting a client.

"The client must connect in over TCP to a known host/port. The server accepts the connection, adds it to the list of clients."

So let's decompose that.
1. You need a server.
2. The server listens on some known address/port for TCP connections.
3. The server has a list of active clients.
4. When your client connects in, it is silently added to the active client list.

Going further on that:
1. You need to design and implement the active client list on the server.
2. The list needs to hold a client name, address and socket.
3. That means the client must identify itself on connection (pass it's name), the server could reply by sending the names of the members of the active client list.

As you can see, sending messages up and down is only a small part of the task. You really need to think about what the program will do in some detail, and the design.

A good way to do that is the think of the ways in which the program will be used and write them down. These "Use Cases" (as they're called in UML) become the requirements and drive the design.

If you can't think about a Use Case and how you might deal with it, you most probably won't be able to code it.
Last edited on
I'm so confused... your while has a break not nested within a seperate loop. I believe that could be part of your problem.
@carpalTunnel: You're right, I corrected it. But it doesn't work either.

@kbw: 1. I only want some kind of chat program for two PCs.
2. My code already does this, but after one message from the client and
the reply from the server an errror ocures.
3. I'm new in Winsocket programming and I copied the basic
winsocket-code from MSDN and modified it to get it work as described
in 2. .
Topic archived. No new replies allowed.