From bbab73a63b8c7b50e8a8cb228999d45024fad984 Mon Sep 17 00:00:00 2001
From: "Matthias (think)" <matthias@mpb.li>
Date: Wed, 11 Jul 2012 11:49:12 +0200
Subject: added unmodified mmbtools

---
 src/UdpSocket.cpp | 455 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 455 insertions(+)
 create mode 100644 src/UdpSocket.cpp

(limited to 'src/UdpSocket.cpp')

diff --git a/src/UdpSocket.cpp b/src/UdpSocket.cpp
new file mode 100644
index 0000000..f3b2ca0
--- /dev/null
+++ b/src/UdpSocket.cpp
@@ -0,0 +1,455 @@
+/*
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Her Majesty the
+   Queen in Right of Canada (Communications Research Center Canada)
+   */
+/*
+   This file is part of CRC-DabMux.
+
+   CRC-DabMux is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation, either version 3 of the
+   License, or (at your option) any later version.
+
+   CRC-DabMux is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with CRC-DabMux.  If not, see <http://www.gnu.org/licenses/>.
+   */
+
+#include "UdpSocket.h"
+
+#include <iostream>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+#ifdef TRACE_ON
+# ifndef TRACE_CLASS
+#  define TRACE_CLASS(class, func) cout <<"-" <<(class) <<"\t(" <<this <<")::" <<(func) <<endl
+#  define TRACE_STATIC(class, func) cout <<"-" <<(class) <<"\t(static)::" <<(func) <<endl
+# endif
+#else
+# ifndef TRACE_CLASS
+#  define TRACE_CLASS(class, func)
+#  define TRACE_STATIC(class, func)
+# endif
+#endif
+
+
+/// Must be call once before doing any operation on sockets
+int UdpSocket::init()
+{
+#ifdef _WIN32
+  WSADATA wsaData;
+  WORD wVersionRequested = wVersionRequested = MAKEWORD( 2, 2 );
+  
+  int res = WSAStartup( wVersionRequested, &wsaData );
+  if (res) {
+    setInetError("Can't initialize winsock");
+    return -1;
+  }
+#endif
+  return 0;
+}
+
+
+/// Must be call once before leaving application
+int UdpSocket::clean()
+{
+#ifdef _WIN32
+  int res = WSACleanup();
+  if (res) {
+    setInetError("Can't initialize winsock");
+    return -1;
+  }
+#endif
+  return 0;
+}
+
+
+/**
+ *  Two step constructor. Create must be called prior to use this
+ *  socket.
+ */
+UdpSocket::UdpSocket() :
+  listenSocket(INVALID_SOCKET)
+{
+  TRACE_CLASS("UdpSocket", "UdpSocket()");
+}
+
+
+/**
+ *  One step constructor.
+ *  @param port The port number on which the socket will be bind
+ *  @param name The IP address on which the socket will be bind.
+ *              It is used to bind the socket on a specific interface if
+ *              the computer have many NICs.
+ */
+UdpSocket::UdpSocket(int port, char *name) :
+  listenSocket(INVALID_SOCKET)
+{
+  TRACE_CLASS("UdpSocket", "UdpSocket(int, char*)");
+  create(port, name);
+}
+
+
+/**
+ *  This functin set blocking mode. The socket can be blocking or not,
+ *  depending of the parametre. By default, the socket is blocking.
+ *  @param block If true, set the socket blocking, otherwise set non-blocking
+ *  @return 0  if ok
+ *          -1 if error
+ */
+int UdpSocket::setBlocking(bool block)
+{
+#ifdef _WIN32
+	unsigned long res = block ? 0 : 1;
+	if (ioctlsocket(listenSocket, FIONBIO, &res) != 0) {
+        setInetError("Can't change blocking state of socket");
+        return -1;
+	}
+    return 0;
+#else
+  int res;
+  if (block)
+    res = fcntl(listenSocket, F_SETFL, 0);
+  else
+    res = fcntl(listenSocket, F_SETFL, O_NONBLOCK);
+  if (res == SOCKET_ERROR) {
+    setInetError("Can't change blocking state of socket");
+    return -1;
+  }
+  return 0;
+#endif
+}
+
+
+/**
+ *  Two step initializer. This function must be called after the constructor
+ *  without argument as been called.
+ *  @param port The port number on which the socket will be bind
+ *  @param name The IP address on which the socket will be bind.
+ *              It is used to bind the socket on a specific interface if
+ *              the computer have many NICs.
+ *  @return 0  if ok
+ *          -1 if error
+ */
+int UdpSocket::create(int port, char *name)
+{
+  TRACE_CLASS("UdpSocket", "create(int, char*)");
+  if (listenSocket != INVALID_SOCKET)
+    closesocket(listenSocket);
+  address.setAddress(name);
+  address.setPort(port);
+  if ((listenSocket = socket(PF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
+    setInetError("Can't create socket");
+    return -1;
+  }
+  reuseopt_t reuse = 1;
+  if (setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))
+      == SOCKET_ERROR) {
+    setInetError("Can't reuse address");
+    return -1;
+  }
+  if (bind(listenSocket, address.getAddress(), sizeof(sockaddr_in)) == SOCKET_ERROR) {
+    setInetError("Can't bind socket");
+    closesocket(listenSocket);
+    listenSocket = INVALID_SOCKET;
+    return -1;
+  }
+  return 0;
+}
+
+
+/// Destructor
+UdpSocket::~UdpSocket() {
+  TRACE_CLASS("UdpSocket", "~UdpSocket()");
+  if (listenSocket != INVALID_SOCKET)
+    closesocket(listenSocket);
+}
+
+
+/**
+ *  Receive an UDP packet.
+ *  @param packet The packet that will receive data. The address will be set
+ *                to the source address.
+ *  @return 0 if ok, -1 if error
+ */
+int UdpSocket::receive(UdpPacket &packet)
+{
+  TRACE_CLASS("UdpSocket", "receive(UdpPacket)");
+  socklen_t addrSize;
+  addrSize = sizeof(*packet.getAddress().getAddress());
+  int ret = recvfrom(listenSocket, packet.getData(), packet.getSize() - packet.getOffset(), 0,
+		     packet.getAddress().getAddress(), &addrSize);
+  if (ret == SOCKET_ERROR) {
+    packet.setLength(0);
+#ifndef _WIN32
+  if (errno == EAGAIN)
+    return 0;
+#endif
+    setInetError("Can't receive UDP packet");
+    return -1;
+  }
+  packet.setLength(ret);
+  if (ret == (long)packet.getSize()) {
+    packet.setSize(packet.getSize() << 1);
+  }
+  return 0;
+}
+
+
+/**
+ *  Send an UDP packet.
+ *  @param packet The UDP packet to be sent. It includes the data and the
+ *                destination address
+ *  return 0 if ok, -1 if error
+ */
+int UdpSocket::send(UdpPacket &packet)
+{
+#ifdef DUMP
+  TRACE_CLASS("UdpSocket", "send(UdpPacket)");
+#endif
+  int ret = sendto(listenSocket, packet.getData(), packet.getLength(), 0,
+		   packet.getAddress().getAddress(), sizeof(*packet.getAddress().getAddress()));
+  if (ret == SOCKET_ERROR
+#ifndef _WIN32
+      && errno != ECONNREFUSED
+#endif
+      ) {
+    setInetError("Can't send UDP packet");
+    return -1;
+  }
+  return 0;
+}
+
+
+/**
+ *  Must be called to receive data on a multicast address.
+ *  @param groupname The multica
+st address to join.
+ *  @return 0 if ok, -1 if error
+ */
+int UdpSocket::joinGroup(char* groupname)
+{
+  TRACE_CLASS("UdpSocket", "joinGroup(char*)");
+#ifdef _WIN32
+  ip_mreq group;
+#else
+  ip_mreqn group;
+#endif
+  if ((group.imr_multiaddr.s_addr = inet_addr(groupname)) == INADDR_NONE) {
+    setInetError(groupname);
+    return -1;
+  }
+  if (!IN_MULTICAST(ntohl(group.imr_multiaddr.s_addr))) {
+    setInetError("Not a multicast address");
+    return -1;
+  }
+#ifdef _WIN32
+  group.imr_interface.s_addr = 0;
+  if (setsockopt(listenSocket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&group, sizeof(group))
+      == SOCKET_ERROR) {
+    setInetError("Can't join multicast group");
+    return -1;
+  }
+#else
+  group.imr_address.s_addr = htons(INADDR_ANY);;
+  group.imr_ifindex = 0;
+  if (setsockopt(listenSocket, SOL_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group))
+      == SOCKET_ERROR) {
+    setInetError("Can't join multicast group");
+  }
+#endif
+  return 0;
+}
+
+  
+/**
+ *  Constructs an UDP packet.
+ *  @param initSize The initial size of the data buffer
+ */
+UdpPacket::UdpPacket(unsigned int initSize) :
+  dataBuf(new char[initSize]),
+  length(0),
+  size(initSize),
+  offset(0)
+{
+  TRACE_CLASS("UdpPacket", "UdpPacket(unsigned int)");
+  if (dataBuf == NULL)
+    size = 0;
+}
+
+
+/// Destructor
+UdpPacket::~UdpPacket()
+{
+  TRACE_CLASS("UdpPacket", "~UdpPacket()");
+  if (dataBuf != NULL) {
+    delete []dataBuf;
+    dataBuf = NULL;
+  }
+}
+  
+
+/**
+ *  Changes size of the data buffer size. \a Length + \a offset data will be copied
+ *  in the new buffer.
+ *  @warning The pointer to data will be changed
+ *  @param newSize The new data buffer size
+ */
+void UdpPacket::setSize(unsigned newSize)
+{
+  TRACE_CLASS("UdpPacket", "setSize(unsigned)");
+  char *tmp = new char[newSize];
+  if (length > newSize)
+    length = newSize;
+  if (tmp) {
+    memcpy(tmp, dataBuf, length);
+    delete []dataBuf;
+    dataBuf = tmp;
+    size = newSize;
+  }
+}
+
+
+/**
+ *  Give the pointer to data. It is ajusted with the \a offset.
+ *  @warning This pointer change. when the \a size of the buffer and the \a offset change.
+ *  @return The pointer
+ */
+char *UdpPacket::getData()
+{
+  return dataBuf + offset;
+}
+
+
+/**
+ *  Add some data at the end of data buffer and adjust size.
+ *  @param data Pointer to the data to add
+ *  @param size Size in bytes of new data
+ */
+void UdpPacket::addData(void *data, unsigned size)
+{
+  if (length + size > this->size) {
+    setSize(this->size << 1);
+  }
+  memcpy(dataBuf + length, data, size);
+  length += size;
+}
+
+
+/**
+ *  Returns the length of useful data. Data before the \a offset are ignored.
+ *  @return The data length
+ */
+unsigned long UdpPacket::getLength()
+{
+  return length - offset;
+}
+
+
+/**
+ *  Returns the size of the data buffer.
+ *  @return The data buffer size
+ */
+unsigned long UdpPacket::getSize()
+{
+  return size;
+}
+
+
+/**
+ *  Returns the offset value.
+ *  @return The offset value
+ */
+unsigned long UdpPacket::getOffset()
+{
+  return offset;
+}
+
+
+/**
+ *  Sets the data length value. Data before the \a offset are ignored.
+ *  @param len The new length of data
+ */
+void UdpPacket::setLength(unsigned long len)
+{
+  length = len + offset;
+}
+
+
+/**
+ *  Sets the data offset. Data length is ajusted to ignore data before the \a offset.
+ *  @param val The new data offset.
+ */
+void UdpPacket::setOffset(unsigned long val)
+{
+  offset = val;
+  if (offset > length)
+    length = offset;
+}
+
+
+/**
+ *  Returns the UDP address of the data.
+ *  @return The UDP address
+ */
+InetAddress &UdpPacket::getAddress()
+{
+  return address;
+}
+
+/*
+WSAEINTR
+WSAEBADF
+WSAEACCES
+WSAEFAULT
+WSAEINVAL
+WSAEMFILE
+WSAEWOULDBLOCK
+WSAEINPROGRESS
+WSAEALREADY
+WSAENOTSOCK
+WSAEDESTADDRREQ
+WSAEMSGSIZE
+WSAEPROTOTYPE
+WSAENOPROTOOPT
+WSAEPROTONOSUPPORT
+WSAESOCKTNOSUPPORT
+WSAEOPNOTSUPP
+WSAEPFNOSUPPORT
+WSAEAFNOSUPPORT
+WSAEADDRINUSE
+WSAEADDRNOTAVAIL
+WSAENETDOWN
+WSAENETUNREACH
+WSAENETRESET
+WSAECONNABORTED
+WSAECONNRESET
+WSAENOBUFS
+WSAEISCONN
+WSAENOTCONN
+WSAESHUTDOWN
+WSAETOOMANYREFS
+WSAETIMEDOUT
+WSAECONNREFUSED
+WSAELOOP
+WSAENAMETOOLONG
+WSAEHOSTDOWN
+WSAEHOSTUNREACH
+WSAENOTEMPTY
+WSAEPROCLIM
+WSAEUSERS
+WSAEDQUOT
+WSAESTALE
+WSAEREMOTE
+WSAEDISCON
+WSASYSNOTREADY
+WSAVERNOTSUPPORTED
+WSANOTINITIALISED
+*/
-- 
cgit v1.2.3