UDP respond on connected socket

Question

So I've been programming with TCP for quite a while, and decided to pick up UDP. I'm not quite sure what needs to be done in order for me to have communication both ways across the WAN(or lan for that matter, easier on lan because I could just open two ports) With UDP once I send information from client to server how can I respond on that socket. Is there a way to connect directly?

(Current quick functions)

int udpsock(int port, const char* addr){
 int handle = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
 if (handle < 1)
    return -1; 

 sockaddr_in address;
 address.sin_family = AF_INET;
 if (addr == INADDR_ANY)
     address.sin_addr.s_addr = INADDR_ANY;
 else
     address.sin_addr.s_addr = inet_addr(addr);
 address.sin_port = htons( (unsigned short) port );

 if ( bind( handle, (const sockaddr*) &address, sizeof(sockaddr_in) ) < 0 )
     return -1;

 return handle;
}
string recvudp(int sock,const int size){
 sockaddr_in SenderAddr;
 int SenderAddrSize = sizeof (SenderAddr);
 char buf[size];

 int retsize = recvfrom(sock, buf, sizeof(buf), 0, (SOCKADDR *) & SenderAddr, &Sen derAddrSize);
 if (retsize == -1){
     cout << "\nRecv Error : " << WSAGetLastError();
     if (WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == 0){
      return "";
     }
     return "\0";
 }
 else if (retsize < size){
     buf[retsize] = NULL;
 }
 return buf;
}
int sendudp(string str, string ip, unsigned short port, int sock){
 sockaddr_in dest;
 dest.sin_family = AF_INET;
 dest.sin_addr.s_addr = inet_addr( ip.c_str() );
 dest.sin_port = htons( port );

 int ret = sendto(sock,str.c_str(),str.size(),0, (sockaddr*)&dest,sizeof(dest));

 if (ret == -1){
  cout << "\nSend Error Code : " <<  WSAGetLastError();
 }

 return ret;
}

With this it's pretty easy to make a socket with port xxxx and have the partner send on that port to get data to the client, the forth part is where I'm having some trouble =]

Answer 1

I assume that functions you posted should be shared between client and server. They need to be slightly modified in order to achieve that. E.g. on the server side, recvudp should return client address (possibly as an out parameter) as it is needed later for sending message back to it. Furthermore, as client address structure is already filled (in recvudp on the server side or manually on the client side) we can just pass it to sendudp as its argument.

I've played with this a bit and created two simple projects in Visual Studio 2010: UDP Server and client. They both use shared functions mentioned above. This code is far from perfect and is aimed only to show basic UDP socket communication.

Shared.h:

#ifndef SHARED_H
#define SHARED_H
#include <winsock2.h>
#include <string>

int udpsock(int port, const char* addr);
std::string recvudp(int sock, const int size, sockaddr_in& SenderAddr, int& SenderAddrSize);
int sendudp(std::string str, sockaddr_in dest, int sock);

#endif

Shared.cpp:

#include "Include\shared.h" // path to header - you might use different one
#include <iostream>
using namespace std;

int udpsock(int port, const char* addr)
{
    int handle = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );

    if (handle < 1)
        return -1; 

    sockaddr_in address;
    address.sin_family = AF_INET;
    if (addr == INADDR_ANY)
        address.sin_addr.s_addr = INADDR_ANY;
    else
        address.sin_addr.s_addr = inet_addr(addr);
    address.sin_port = htons( (unsigned short) port );

    if ( bind( handle, (const sockaddr*) &address, sizeof(sockaddr_in) ) < 0 )
        return -1;

    return handle;
}

// function should return sender address info (for the code the server)
string recvudp(int sock, const int size, sockaddr_in& SenderAddr, int& SenderAddrSize)
{
        // TODO: use std::vector<char> here instead of char array
    char* buf = 0;
    buf = new char[size];

    int retsize = recvfrom(sock, buf, size, 0, (sockaddr*) &SenderAddr, &SenderAddrSize);

    if(retsize == -1)
    {
        cout << "\nRecv Error : " << WSAGetLastError();

        if (WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == 0)
        {
            return "";
        }

        return "\0";
    }
    else if (retsize < size)
    {
        buf[retsize] = NULL;
    }

    string str(buf);
    delete[] buf;

    return str;
}

// On the client side, prepare dest like this:
//  sockaddr_in dest;
//  dest.sin_family = AF_INET;
//  dest.sin_addr.s_addr = inet_addr(ip.c_str());
//  dest.sin_port = htons(port);
int sendudp(string str, sockaddr_in dest, int sock)
{
    int ret = sendto(sock,str.c_str(),str.size(),0, (sockaddr*)&dest,sizeof(dest));

    if (ret == -1)
    {
        cout << "\nSend Error Code : " <<  WSAGetLastError();
    }

    return ret;
}

Server: main.cpp:

#include <winsock2.h>
#include <string.h>
#include <iostream>
#include "..\Shared\Include\shared.h"

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

#define SERVER_PORT 27015
#define MAX_MSG 1024

using namespace std;

int main(int argc, char *argv[]) 
{  
    WSADATA wsaData;

    int nResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

    if(nResult != NO_ERROR) 
    {
        cout << "WSAStartup failed with error: " << nResult << endl;
        return 1;
    }

    sock = udpsock(SERVER_PORT, "127.0.0.1");
    cout << "Waiting for datagram on port: " << SERVER_PORT << endl;

    while(1) 
    {
        sockaddr_in clientAddr;     
        // receive message
        int clientAddrLen = sizeof(clientAddr);

        cout << "Received message from the client: " << recvudp(sock, MAX_MSG, clientAddr, clientAddrLen) << endl; 

        sendudp("Hello from server!", clientAddr, sock);
    }

    WSACleanup();
    return 0;
}

Client: main.cpp:

#include <winsock2.h>
#include <iostream>
#include "..\Shared\Include\shared.h"
using namespace std;

#define MAX_MSG 1024

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

int main(int argc, char* argv[])
{   
    WSADATA wsaData;

    int nResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (nResult != NO_ERROR) 
    {
        cout << "WSAStartup failed with error: " << nResult << endl;
        return 1;
    }

    SOCKET sock = INVALID_SOCKET;

    // Create a socket for sending data - it does not need to be binded like listening socket!
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    if(sock == INVALID_SOCKET) 
    {
        cout << socket failed with error: " <<  WSAGetLastError() << endl;
        WSACleanup();
        return 1;
    }

    unsigned short Port = 27015;    

    sockaddr_in dest;
    dest.sin_family = AF_INET;
    dest.sin_addr.s_addr = inet_addr("127.0.0.1");
    dest.sin_port = htons(Port);

    sendudp("Hello from client!", dest, sock);

    sockaddr_in RecvAddr;    
    int recvaddrlen = sizeof(RecvAddr);

    cout << "Received message from the server: " << recvudp(sock, MAX_MSG, RecvAddr, recvaddrlen) << endl; 

    cout << "Closing socket..." << endl; 

    nResult = closesocket(sock);

    if(nResult == SOCKET_ERROR) 
    {
        cout << "closesocket failed with error: " << WSAGetLastError() << endl;
        WSACleanup();
        return 1;
    }

    WSACleanup();
    return 0;
}

If you run client twice output is:

Server:

Waiting for datagram on port: 27015
Received message from the client: Hello from client!
Received message from the client: Hello from client!

Client:

Received message from the server: Hello from server!
Closing socket...

UDP is connectionless protocol, server just needs to start listening on UDP port and client can send data (datagram) immediately, there is no need for connection establishment (e.g. with connect()/accept(), like in TCP).

Answer 2

Make your sendudp function take a sockaddr_in. You get one back from recvfrom and can pass it to sendto. Alternatively, pass the received sockaddr_in to connect and use send from then on.