udp6.cc

   1 /*
   2     Copyright 2020 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP.  If not, see <https://www.gnu.org/licenses/>.
  18 */
  19
  20 #ifndef WIN32
  21 #include <netdb.h>
  22 #include <unistd.h>
  23 #include <arpa/inet.h>
  24 #include <sys/time.h>
  25 #include <netinet/in.h>
  26 #define SOCKET_ERROR 0
  27 #include <net/if.h>
  28 #else
  29 #include <winsock2.h>
  30 #include <Ws2tcpip.h>
  31 #include <sys/timeb.h>
  32 #endif
  33
  34 #include <sys/types.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <fcntl.h>
  40
  41 #include "log.h"
  42
  43 #include "udp6.h"
  44
  45 static const char* TAG = "UDP6";
  46
  47 UDP6::~UDP6()
  48 {
  49   if (initted) shutdown();
  50 }
  51
  52 int UDP6::init(USHORT tPort)
  53 {
  54   if (initted) return 0;
  55   myPort = tPort;
  56   addrlen = sizeof(struct sockaddr_in6);
  57
  58   if ((socketnum = socket(AF_INET6, SOCK_DGRAM, 0)) == -1)
  59   { perror("socket"); return 0; }
  60
  61   memset(&myAddr, 0, sizeof(myAddr));
  62   myAddr.sin6_family = AF_INET6;        // host byte order
  63   myAddr.sin6_port = htons(myPort);     // short, network byte order
  64   myAddr.sin6_addr = in6addr_any;
  65
  66   /*
  67    * FIXME This _might_ need porting to Windows
  68     myAddr.sin_addr.s_addr = getIPNumber(iterate_ip++); // auto-fill with my IP
  69     inet_pton(AF_INET6, "", &myAddr.sin6_addr);
  70   */
  71
  72   if (bind(socketnum, reinterpret_cast<struct sockaddr *>(&myAddr), addrlen) == -1)
  73   { perror("bind6"); return 0; }
  74
  75   FD_ZERO(&readfds);
  76   FD_SET(socketnum, &readfds);
  77   tv.tv_sec = 0;
  78   tv.tv_usec = 0;
  79
  80   initted = true;
  81
  82   return 1;
  83 }
  84
  85 void UDP6::shutdown()
  86 {
  87   if (!initted) return;
  88   CLOSESOCKET(socketnum);
  89   initted = false;
  90 }
  91
  92 #ifdef WIN32
  93 unsigned char UDP6::waitforMessage(unsigned char how, SOCKET quitPipe)
  94 #else
  95 unsigned char UDP6::waitforMessage(unsigned char how, int quitPipe)
  96 #endif
  97 {
  98   if (!initted) return 0;
  99
 100   /* how = 0 - block
 101      how = 1 - start new wait
 102      how = 2 - continue wait
 103      how = 3 - block, return on byte from quitPipe
 104   */
 105
 106   FD_ZERO(&readfds);
 107   FD_SET(socketnum, &readfds);
 108
 109   struct timeval* passToSelect = NULL;
 110
 111   int sockMaxP1 = socketnum + 1;
 112
 113   if (how == 1)
 114   {
 115     tv.tv_sec = 1;
 116     tv.tv_usec = 500000;
 117     passToSelect = &tv;
 118   }
 119   else if (how == 2)
 120   {
 121     if ((tv.tv_sec == 0) && (tv.tv_usec == 0))  // protection in case timer = 0
 122     {
 123       tv.tv_sec = 1;
 124       tv.tv_usec = 500000;
 125     }
 126     passToSelect = &tv;
 127   }
 128   else if (how == 3)
 129   {
 130     FD_SET(quitPipe, &readfds);
 131     if (quitPipe > socketnum) sockMaxP1 = quitPipe + 1;
 132   }
 133
 134
 135   if (select(sockMaxP1, &readfds, NULL, NULL, passToSelect) <= 0)
 136   {  return 1;  }
 137
 138   if ((how == 3) && FD_ISSET(quitPipe, &readfds)) return 3;
 139
 140   if ((mlength = recvfrom(socketnum, buf, MAXBUFLEN, 0,
 141       reinterpret_cast<struct sockaddr *>(&theirAddr), &addrlen)) == -1)
 142   { perror("recvfrom"); return 0; }
 143   else
 144   {
 145     memset(&buf[mlength], 0, MAXBUFLEN - mlength);
 146     inet_ntop(AF_INET6, &theirAddr.sin6_addr, fromIPA, 40);
 147     fromPort = ntohs(theirAddr.sin6_port);
 148     fromIPisLL = IN6_IS_ADDR_LINKLOCAL(&theirAddr.sin6_addr);
 149     return 2;
 150   }
 151
 152   /* Return 0, failure
 153      Return 1, nothing happened, timer expired
 154      Return 2, packet arrived (timer not expired)
 155   */
 156 }
 157
 158 UINT UDP6::getDataLength(void) const
 159 {
 160   return static_cast<UINT>(mlength);
 161 }
 162
 163 const void* UDP6::getData() const     {  return buf;  }
 164 const char* UDP6::getFromIPA() const  {  return fromIPA;  }
 165 short UDP6::getFromPort() const       {  return fromPort; }
 166 bool UDP6::getFromIPisLL() const      {  return fromIPisLL; }
 167
 168 bool UDP6::send(const char *ipa, USHORT port, char *message, int length, bool mcast)
 169 {
 170   if (!initted) return false;
 171   int sentLength = 0;
 172   errno = 0;
 173
 174   struct sockaddr_in6 sendAddr;
 175   memset(&sendAddr, 0, sizeof(struct sockaddr_in6));
 176   sendAddr.sin6_family = AF_INET6;
 177   inet_pton(AF_INET6, ipa, &sendAddr.sin6_addr);
 178   sendAddr.sin6_port = htons(port);
 179
 180   if (mcast)
 181   {
 182     struct if_nameindex* ifs = if_nameindex();
 183     UINT ifIndex;
 184
 185     for(int i = 0; ifs[i].if_index > 0; i++)
 186     {
 187       ifIndex = ifs[i].if_index;
 188       int res = setsockopt(socketnum, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifIndex, sizeof(ifIndex));
 189       LogNT::getInstance()->debug(TAG, "Transmitting IPv6 MC UDP on {}", ifs[i].if_name);
 190       res = sendto(socketnum, message, length, 0, reinterpret_cast<struct sockaddr *>(&sendAddr), addrlen);
 191       LogNT::getInstance()->debug(TAG, "Result: {}. Errno: {}", res, errno);
 192       errno = 0;
 193     }
 194
 195     if_freenameindex(ifs);
 196   }
 197   else
 198   {
 199     sentLength = sendto(socketnum, message, length, 0, reinterpret_cast<struct sockaddr *>(&sendAddr), addrlen);
 200     if (sentLength == length) return true;
 201     LogNT::getInstance()->error(TAG, "sendto failed, errno = {}", errno);
 202   }
 203
 204   return false;
 205 }
 206
 207 #ifndef WIN32
 208 ULONG UDP6::getIPNumber(ULONG)
 209 {
 210   return INADDR_ANY;
 211 }
 212 #else
 213 ULONG UDP6::getIPNumber(ULONG num)
 214 {
 215   char buffer[100];
 216   ULONG returnaddress;
 217
 218   if (gethostname(buffer,sizeof(buffer))==SOCKET_ERROR)
 219   {
 220     return INADDR_ANY; //well take any address, if we fail
 221   }
 222
 223   struct hostent *hosts=gethostbyname(buffer);
 224   if (hosts==NULL)
 225   {
 226     return INADDR_ANY; //well take any address, if we fail
 227   }
 228
 229   int num_ip=0;
 230   for (num_ip=0;hosts->h_addr_list[num_ip]!=NULL;num_ip++);
 231
 232   int get_ip=(num%num_ip);//Just wrap around, if no interface are present any more
 233   memcpy(&returnaddress, hosts->h_addr_list[get_ip], sizeof(ULONG));
 234   return returnaddress;
 235 }
 236 #endif