Functions

udp.cc File Reference

#include <cassert>
#include <cstdio>
#include <cstring>
#include <errno.h>
#include <iostream>
#include <cstdlib>
#include <time.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netdb.h>
#include <string.h>
#include "stun_udp.h"

Go to the source code of this file.

Functions

Socket openPort (unsigned short port, unsigned int interfaceIp, bool verbose)
 Open a UDP socket to receive on the given port - if port is 0, pick a a port, if interfaceIp!=0 then use ONLY the interface specified instead of all of them.
bool getMessage (Socket fd, char *buf, int *len, unsigned int *srcIp, unsigned short *srcPort, bool verbose)
 recive a UDP message
bool sendMessage (Socket fd, char *buf, int l, unsigned int dstIp, unsigned short dstPort, bool verbose)
 send a UDP message
void initNetwork ()
 set up network - does nothing in unix but needed for windows

Function Documentation

bool getMessage ( Socket  fd,
char *  buf,
int *  len,
unsigned int *  srcIp,
unsigned short *  srcPort,
bool  verbose 
)

recive a UDP message

Definition at line 114 of file udp.cc.

Referenced by stunNatType(), stunOpenSocket(), stunOpenSocketPair(), stunServerProcess(), and stunTest().

{
   assert( fd != STUN_INVALID_SOCKET );

   int originalSize = *len;
   assert( originalSize > 0 );

   struct sockaddr_in from;
   int fromLen = sizeof(from);

   *len = recvfrom(fd,
                   buf,
                   originalSize,
                   0,
                   (struct sockaddr *)&from,
                   (socklen_t*)&fromLen);

   if ( *len == STUN_SOCKET_ERROR )
   {
      int err = getErrno();

      switch (err)
      {
         case ENOTSOCK:
            cerr << "Error fd not a socket" <<   endl;
            break;
         case ECONNRESET:
            cerr << "Error connection reset - host not reachable" <<   endl;
            break;

         default:
            cerr << "Socket Error=" << err << endl;
      }

      return false;
   }

   if ( *len < 0 )
   {
      clog << "socket closed? negative len" << endl;
      return false;
   }

   if ( *len == 0 )
   {
      clog << "socket closed? zero len" << endl;
      return false;
   }

   *srcPort = ntohs(from.sin_port);
   *srcIp = ntohl(from.sin_addr.s_addr);

   if ( (*len)+1 >= originalSize )
   {
      if (verbose)
      {
         clog << "Received a message that was too large" << endl;
      }
      return false;
   }
   buf[*len]=0;

   return true;
}

void initNetwork (  ) 

set up network - does nothing in unix but needed for windows

Definition at line 258 of file udp.cc.

{
#ifdef WIN32
   WORD wVersionRequested = MAKEWORD( 2, 2 );
   WSADATA wsaData;
   int err;

   err = WSAStartup( wVersionRequested, &wsaData );
   if ( err != 0 )
   {
      // could not find a usable WinSock DLL
      cerr << "Could not load winsock" << endl;
      assert(0); // is this is failing, try a different version that 2.2, 1.0 or later will likely work
      exit(1);
   }

   /* Confirm that the WinSock DLL supports 2.2.*/
   /* Note that if the DLL supports versions greater    */
   /* than 2.2 in addition to 2.2, it will still return */
   /* 2.2 in wVersion since that is the version we      */
   /* requested.                                        */

   if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 )
   {
      /* Tell the user that we could not find a usable */
      /* WinSock DLL.                                  */
      WSACleanup( );
      cerr << "Bad winsock verion" << endl;
      assert(0); // is this is failing, try a different version that 2.2, 1.0 or later will likely work
      exit(1);
   }
#endif
}

Socket openPort ( unsigned short  port,
unsigned int  interfaceIp,
bool  verbose 
)

Open a UDP socket to receive on the given port - if port is 0, pick a a port, if interfaceIp!=0 then use ONLY the interface specified instead of all of them.

Definition at line 38 of file udp.cc.

Referenced by stunInitServer(), stunNatType(), stunOpenSocket(), stunOpenSocketPair(), stunServerProcess(), and stunTest().

{
   Socket fd;

   fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
   if ( fd == STUN_INVALID_SOCKET )
   {
      int err = getErrno();
      cerr << "Could not create a UDP socket:" << err << endl;
      return STUN_INVALID_SOCKET;
   }

   struct sockaddr_in addr;
   memset((char*) &(addr),0, sizeof((addr)));
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = htonl(INADDR_ANY);
   addr.sin_port = htons(port);

   if ( (interfaceIp != 0) &&
        ( interfaceIp != 0x100007f ) )
   {
      addr.sin_addr.s_addr = htonl(interfaceIp);
      if (verbose )
      {
         clog << "Binding to interface "
              << hex << "0x" << htonl(interfaceIp) << dec << endl;
      }
   }

   if ( bind( fd,(struct sockaddr*)&addr, sizeof(addr)) != 0 )
   {
      int e = getErrno();

      switch (e)
      {
         case 0:
         {
            cerr << "Could not bind socket" << endl;
            return STUN_INVALID_SOCKET;
         }
         case EADDRINUSE:
         {
            cerr << "Port " << port << " for receiving UDP is in use" << endl;
            return STUN_INVALID_SOCKET;
         }
         break;
         case EADDRNOTAVAIL:
         {
            if ( verbose )
            {
               cerr << "Cannot assign requested address" << endl;
            }
            return STUN_INVALID_SOCKET;
         }
         break;
         default:
         {
            cerr << "Could not bind UDP receive port"
                 << "Error=" << e << " " << strerror(e) << endl;
            return STUN_INVALID_SOCKET;
         }
         break;
      }
   }
   if ( verbose )
   {
      clog << "Opened port " << port << " with fd " << fd << endl;
   }

   assert( fd != STUN_INVALID_SOCKET  );

   return fd;
}

bool sendMessage ( Socket  fd,
char *  buf,
int  l,
unsigned int  dstIp,
unsigned short  dstPort,
bool  verbose 
)

send a UDP message

Definition at line 183 of file udp.cc.

Referenced by stunSendTest(), and stunServerProcess().

{
   assert( fd != STUN_INVALID_SOCKET );

   int s;
   if ( dstPort == 0 )
   {
      // sending on a connected port
      assert( dstIp == 0 );

      s = send(fd,buf,l,0);
   }
   else
   {
      assert( dstIp != 0 );
      assert( dstPort != 0 );

      struct sockaddr_in to;
      int toLen = sizeof(to);
      memset(&to,0,toLen);

      to.sin_family = AF_INET;
      to.sin_port = htons(dstPort);
      to.sin_addr.s_addr = htonl(dstIp);

      s = sendto(fd, buf, l, 0,(sockaddr*)&to, toLen);
   }

   if ( s == STUN_SOCKET_ERROR )
   {
      int e = getErrno();
      switch (e)
      {
         case ECONNREFUSED:
         case EHOSTDOWN:
         case EHOSTUNREACH:
         {
            // quietly ignore this
         }
         break;
         case EAFNOSUPPORT:
         {
            cerr << "err EAFNOSUPPORT in send" << endl;
         }
         break;
         default:
         {
            cerr << "err " << e << " "  << strerror(e) << " in send" << endl;
         }
      }
      return false;
   }

   if ( s == 0 )
   {
      cerr << "no data sent in send" << endl;
      return false;
   }

   if ( s != l )
   {
      if (verbose)
      {
         cerr << "only " << s << " out of " << l << " bytes sent" << endl;
      }
      return false;
   }

   return true;
}