Sockets/UdpSocket.cpp

   1 /** \file UdpSocket.cpp
   2  **     \date  2004-02-13
   3  **     \author grymse@alhem.net
   4 **/
   5 /*
   6 Copyright (C) 2004-2007  Anders Hedstrom
   7
   8 This library is made available under the terms of the GNU GPL.
   9
  10 If you would like to use this library in a closed-source application,
  11 a separate license agreement is available. For information about
  12 the closed-source license agreement for the C++ sockets library,
  13 please visit http://www.alhem.net/Sockets/license.html and/or
  14 email license@alhem.net.
  15
  16 This program is free software; you can redistribute it and/or
  17 modify it under the terms of the GNU General Public License
  18 as published by the Free Software Foundation; either version 2
  19 of the License, or (at your option) any later version.
  20
  21 This program is distributed in the hope that it will be useful,
  22 but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 GNU General Public License for more details.
  25
  26 You should have received a copy of the GNU General Public License
  27 along with this program; if not, write to the Free Software
  28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29 */
  30 #ifdef _WIN32
  31 #ifdef _MSC_VER
  32 #pragma warning(disable:4786)
  33 #endif
  34 #include <stdlib.h>
  35 #else
  36 #include <errno.h>
  37 #endif
  38
  39 #include "ISocketHandler.h"
  40 #include "UdpSocket.h"
  41 #include "Utility.h"
  42 #include "Ipv4Address.h"
  43 #include "Ipv6Address.h"
  44 #ifdef ENABLE_EXCEPTIONS
  45 #include "Exception.h"
  46 #endif
  47 // include this to see strange sights
  48 //#include <linux/in6.h>
  49
  50
  51 #ifdef SOCKETS_NAMESPACE
  52 namespace SOCKETS_NAMESPACE {
  53 #endif
  54
  55
  56 UdpSocket::UdpSocket(ISocketHandler& h, int ibufsz, bool ipv6, int retries) : Socket(h)
  57 , m_ibuf(new char[ibufsz])
  58 , m_ibufsz(ibufsz)
  59 , m_bind_ok(false)
  60 , m_port(0)
  61 , m_last_size_written(-1)
  62 , m_retries(retries)
  63 , m_b_read_ts(false)
  64 {
  65 #ifdef ENABLE_IPV6
  66 #ifdef IPPROTO_IPV6
  67         SetIpv6(ipv6);
  68 #endif
  69 #endif
  70 }
  71
  72
  73 UdpSocket::~UdpSocket()
  74 {
  75         Close();
  76         delete[] m_ibuf;
  77 }
  78
  79
  80 int UdpSocket::Bind(port_t &port, int range)
  81 {
  82 #ifdef ENABLE_IPV6
  83 #ifdef IPPROTO_IPV6
  84         if (IsIpv6())
  85         {
  86                 Ipv6Address ad(port);
  87                 return Bind(ad, range);
  88         }
  89 #endif
  90 #endif
  91         Ipv4Address ad(port);
  92         return Bind(ad, range);
  93 }
  94
  95
  96 int UdpSocket::Bind(const std::string& intf, port_t &port, int range)
  97 {
  98 #ifdef ENABLE_IPV6
  99 #ifdef IPPROTO_IPV6
 100         if (IsIpv6())
 101         {
 102                 Ipv6Address ad(intf, port);
 103                 if (ad.IsValid())
 104                 {
 105                         return Bind(ad, range);
 106                 }
 107                 SetCloseAndDelete();
 108                 return -1;
 109         }
 110 #endif
 111 #endif
 112         Ipv4Address ad(intf, port);
 113         if (ad.IsValid())
 114         {
 115                 return Bind(ad, range);
 116         }
 117         SetCloseAndDelete();
 118         return -1;
 119 }
 120
 121
 122 int UdpSocket::Bind(ipaddr_t a, port_t &port, int range)
 123 {
 124         Ipv4Address ad(a, port);
 125         return Bind(ad, range);
 126 }
 127
 128
 129 #ifdef ENABLE_IPV6
 130 #ifdef IPPROTO_IPV6
 131 int UdpSocket::Bind(in6_addr a, port_t &port, int range)
 132 {
 133         Ipv6Address ad(a, port);
 134         return Bind(ad, range);
 135 }
 136 #endif
 137 #endif
 138
 139
 140 int UdpSocket::Bind(SocketAddress& ad, int range)
 141 {
 142         if (GetSocket() == INVALID_SOCKET)
 143         {
 144                 Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
 145         }
 146         if (GetSocket() != INVALID_SOCKET)
 147         {
 148                 SetNonblocking(true);
 149                 int n = bind(GetSocket(), ad, ad);
 150                 int tries = range;
 151                 while (n == -1 && tries--)
 152                 {
 153                         ad.SetPort(ad.GetPort() + 1);
 154                         n = bind(GetSocket(), ad, ad);
 155                 }
 156                 if (n == -1)
 157                 {
 158                         Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 159                         SetCloseAndDelete();
 160 #ifdef ENABLE_EXCEPTIONS
 161                         throw Exception("bind() failed for UdpSocket, port:range: " + Utility::l2string(ad.GetPort()) + ":" + Utility::l2string(range));
 162 #endif
 163                         return -1;
 164                 }
 165                 m_bind_ok = true;
 166                 m_port = ad.GetPort();
 167                 return 0;
 168         }
 169         return -1;
 170 }
 171
 172
 173 /** if you wish to use Send, first Open a connection */
 174 bool UdpSocket::Open(ipaddr_t l, port_t port)
 175 {
 176         Ipv4Address ad(l, port);
 177         return Open(ad);
 178 }
 179
 180
 181 bool UdpSocket::Open(const std::string& host, port_t port)
 182 {
 183 #ifdef ENABLE_IPV6
 184 #ifdef IPPROTO_IPV6
 185         if (IsIpv6())
 186         {
 187                 Ipv6Address ad(host, port);
 188                 if (ad.IsValid())
 189                 {
 190                         return Open(ad);
 191                 }
 192                 return false;
 193         }
 194 #endif
 195 #endif
 196         Ipv4Address ad(host, port);
 197         if (ad.IsValid())
 198         {
 199                 return Open(ad);
 200         }
 201         return false;
 202 }
 203
 204
 205 #ifdef ENABLE_IPV6
 206 #ifdef IPPROTO_IPV6
 207 bool UdpSocket::Open(struct in6_addr& a, port_t port)
 208 {
 209         Ipv6Address ad(a, port);
 210         return Open(ad);
 211 }
 212 #endif
 213 #endif
 214
 215
 216 bool UdpSocket::Open(SocketAddress& ad)
 217 {
 218         if (GetSocket() == INVALID_SOCKET)
 219         {
 220                 Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
 221         }
 222         if (GetSocket() != INVALID_SOCKET)
 223         {
 224                 SetNonblocking(true);
 225                 if (connect(GetSocket(), ad, ad) == -1)
 226                 {
 227                         Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 228                         SetCloseAndDelete();
 229                         return false;
 230                 }
 231                 SetConnected();
 232                 return true;
 233         }
 234         return false;
 235 }
 236
 237
 238 void UdpSocket::CreateConnection()
 239 {
 240 #ifdef ENABLE_IPV6
 241 #ifdef IPPROTO_IPV6
 242         if (IsIpv6())
 243         {
 244                 if (GetSocket() == INVALID_SOCKET)
 245                 {
 246                         SOCKET s = CreateSocket(AF_INET6, SOCK_DGRAM, "udp");
 247                         if (s == INVALID_SOCKET)
 248                         {
 249                                 return;
 250                         }
 251                         SetNonblocking(true, s);
 252                         Attach(s);
 253                 }
 254                 return;
 255         }
 256 #endif
 257 #endif
 258         if (GetSocket() == INVALID_SOCKET)
 259         {
 260                 SOCKET s = CreateSocket(AF_INET, SOCK_DGRAM, "udp");
 261                 if (s == INVALID_SOCKET)
 262                 {
 263                         return;
 264                 }
 265                 SetNonblocking(true, s);
 266                 Attach(s);
 267         }
 268 }
 269
 270
 271 /** send to specified address */
 272 void UdpSocket::SendToBuf(const std::string& h, port_t p, const char *data, int len, int flags)
 273 {
 274 #ifdef ENABLE_IPV6
 275 #ifdef IPPROTO_IPV6
 276         if (IsIpv6())
 277         {
 278                 Ipv6Address ad(h, p);
 279                 if (ad.IsValid())
 280                 {
 281                         SendToBuf(ad, data, len, flags);
 282                 }
 283                 return;
 284         }
 285 #endif
 286 #endif
 287         Ipv4Address ad(h, p);
 288         if (ad.IsValid())
 289         {
 290                 SendToBuf(ad, data, len, flags);
 291         }
 292 }
 293
 294
 295 /** send to specified address */
 296 void UdpSocket::SendToBuf(ipaddr_t a, port_t p, const char *data, int len, int flags)
 297 {
 298         Ipv4Address ad(a, p);
 299         SendToBuf(ad, data, len, flags);
 300 }
 301
 302
 303 #ifdef ENABLE_IPV6
 304 #ifdef IPPROTO_IPV6
 305 void UdpSocket::SendToBuf(in6_addr a, port_t p, const char *data, int len, int flags)
 306 {
 307         Ipv6Address ad(a, p);
 308         SendToBuf(ad, data, len, flags);
 309 }
 310 #endif
 311 #endif
 312
 313
 314 void UdpSocket::SendToBuf(SocketAddress& ad, const char *data, int len, int flags)
 315 {
 316         if (GetSocket() == INVALID_SOCKET)
 317         {
 318                 Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
 319         }
 320         if (GetSocket() != INVALID_SOCKET)
 321         {
 322                 SetNonblocking(true);
 323                 if ((m_last_size_written = sendto(GetSocket(), data, len, flags, ad, ad)) == -1)
 324                 {
 325                         Handler().LogError(this, "sendto", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 326                 }
 327         }
 328 }
 329
 330
 331 void UdpSocket::SendTo(const std::string& a, port_t p, const std::string& str, int flags)
 332 {
 333         SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 334 }
 335
 336
 337 void UdpSocket::SendTo(ipaddr_t a, port_t p, const std::string& str, int flags)
 338 {
 339         SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 340 }
 341
 342
 343 #ifdef ENABLE_IPV6
 344 #ifdef IPPROTO_IPV6
 345 void UdpSocket::SendTo(in6_addr a, port_t p, const std::string& str, int flags)
 346 {
 347         SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 348 }
 349 #endif
 350 #endif
 351
 352
 353 void UdpSocket::SendTo(SocketAddress& ad, const std::string& str, int flags)
 354 {
 355         SendToBuf(ad, str.c_str(), (int)str.size(), flags);
 356 }
 357
 358
 359 /** send to connected address */
 360 void UdpSocket::SendBuf(const char *data, size_t len, int flags)
 361 {
 362         if (!IsConnected())
 363         {
 364                 Handler().LogError(this, "SendBuf", 0, "not connected", LOG_LEVEL_ERROR);
 365                 return;
 366         }
 367         if ((m_last_size_written = send(GetSocket(), data, (int)len, flags)) == -1)
 368         {
 369                 Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 370         }
 371 }
 372
 373
 374 void UdpSocket::Send(const std::string& str, int flags)
 375 {
 376         SendBuf(str.c_str(), (int)str.size(), flags);
 377 }
 378
 379
 380 #ifndef _WIN32
 381 int UdpSocket::ReadTS(char *ioBuf, int inBufSize, struct sockaddr *from, socklen_t fromlen, struct timeval *ts)
 382 {
 383         struct msghdr msg;
 384         struct iovec vec[1];
 385         union {
 386                 struct cmsghdr cm;
 387                 char data[CMSG_SPACE(sizeof(struct timeval))];
 388         } cmsg_un;
 389         struct cmsghdr *cmsg;
 390         struct timeval *tv;
 391
 392         vec[0].iov_base = ioBuf;
 393         vec[0].iov_len = inBufSize;
 394
 395         memset(&msg, 0, sizeof(msg));
 396         memset(from, 0, fromlen);
 397         memset(ioBuf, 0, inBufSize);
 398         memset(&cmsg_un, 0, sizeof(cmsg_un));
 399
 400         msg.msg_name = (caddr_t)from;
 401         msg.msg_namelen = fromlen;
 402         msg.msg_iov = vec;
 403         msg.msg_iovlen = 1;
 404         msg.msg_control = cmsg_un.data;
 405         msg.msg_controllen = sizeof(cmsg_un.data);
 406         msg.msg_flags = 0;
 407
 408         // Original version - for reference only
 409         //int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 410
 411         int n = recvmsg(GetSocket(), &msg, MSG_DONTWAIT);
 412
 413         // now ioBuf will contain the data, as if we used recvfrom
 414
 415         // Now get the time
 416         if(n != -1 && msg.msg_controllen >= sizeof(struct cmsghdr) && !(msg.msg_flags & MSG_CTRUNC))
 417         {
 418                 tv = 0;
 419                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg))
 420                 {
 421                         if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_TIMESTAMP)
 422                         {
 423                                 tv = (struct timeval *)CMSG_DATA(cmsg);
 424                         }
 425                 }
 426                 if (tv)
 427                 {
 428                         memcpy(ts, tv, sizeof(struct timeval));
 429                 }
 430         }
 431         // The address is in network order, but that's OK right now
 432         return n;
 433 }
 434 #endif
 435
 436
 437 void UdpSocket::OnRead()
 438 {
 439 #ifdef ENABLE_IPV6
 440 #ifdef IPPROTO_IPV6
 441         if (IsIpv6())
 442         {
 443                 struct sockaddr_in6 sa;
 444                 socklen_t sa_len = sizeof(sa);
 445                 if (m_b_read_ts)
 446                 {
 447                         struct timeval ts;
 448                         Utility::GetTime(&ts);
 449 #ifdef _WIN32
 450                         int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 451 #else
 452                         int n = ReadTS(m_ibuf, m_ibufsz, (struct sockaddr *)&sa, sa_len, &ts);
 453 #endif
 454                         if (n > 0)
 455                         {
 456                                 this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len, &ts);
 457                         }
 458                         else
 459                         if (n == -1)
 460                         {
 461 #ifdef _WIN32
 462                                 if (Errno != WSAEWOULDBLOCK)
 463 #else
 464                                 if (Errno != EWOULDBLOCK)
 465 #endif
 466                                         Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 467                         }
 468                         return;
 469                 }
 470                 int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 471                 int q = m_retries; // receive max 10 at one cycle
 472                 while (n > 0)
 473                 {
 474                         if (sa_len != sizeof(sa))
 475                         {
 476                                 Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
 477                         }
 478                         this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
 479                         if (!q--)
 480                                 break;
 481                         //
 482                         n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 483                 }
 484                 if (n == -1)
 485                 {
 486 #ifdef _WIN32
 487                         if (Errno != WSAEWOULDBLOCK)
 488 #else
 489                         if (Errno != EWOULDBLOCK)
 490 #endif
 491                                 Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 492                 }
 493                 return;
 494         }
 495 #endif
 496 #endif
 497         struct sockaddr_in sa;
 498         socklen_t sa_len = sizeof(sa);
 499         if (m_b_read_ts)
 500         {
 501                 struct timeval ts;
 502                 Utility::GetTime(&ts);
 503 #ifdef _WIN32
 504                 int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 505 #else
 506                 int n = ReadTS(m_ibuf, m_ibufsz, (struct sockaddr *)&sa, sa_len, &ts);
 507 #endif
 508                 if (n > 0)
 509                 {
 510                         this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len, &ts);
 511                 }
 512                 else
 513                 if (n == -1)
 514                 {
 515 #ifdef _WIN32
 516                         if (Errno != WSAEWOULDBLOCK)
 517 #else
 518                         if (Errno != EWOULDBLOCK)
 519 #endif
 520                                 Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 521                 }
 522                 return;
 523         }
 524         int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 525         int q = m_retries;
 526         while (n > 0)
 527         {
 528                 if (sa_len != sizeof(sa))
 529                 {
 530                         Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
 531                 }
 532                 this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
 533                 if (!q--)
 534                         break;
 535                 //
 536                 n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 537         }
 538         if (n == -1)
 539         {
 540 #ifdef _WIN32
 541                 if (Errno != WSAEWOULDBLOCK)
 542 #else
 543                 if (Errno != EWOULDBLOCK)
 544 #endif
 545                         Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 546         }
 547 }
 548
 549
 550 void UdpSocket::SetBroadcast(bool b)
 551 {
 552         int one = 1;
 553         int zero = 0;
 554
 555         if (GetSocket() == INVALID_SOCKET)
 556         {
 557                 CreateConnection();
 558         }
 559         if (b)
 560         {
 561                 if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof(one)) == -1)
 562                 {
 563                         Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 564                 }
 565         }
 566         else
 567         {
 568                 if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &zero, sizeof(zero)) == -1)
 569                 {
 570                         Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 571                 }
 572         }
 573 }
 574
 575
 576 bool UdpSocket::IsBroadcast()
 577 {
 578         int is_broadcast = 0;
 579         socklen_t size;
 580
 581         if (GetSocket() == INVALID_SOCKET)
 582         {
 583                 CreateConnection();
 584         }
 585         if (getsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&is_broadcast, &size) == -1)
 586         {
 587                 Handler().LogError(this, "IsBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 588         }
 589         return is_broadcast != 0;
 590 }
 591
 592
 593 void UdpSocket::SetMulticastTTL(int ttl)
 594 {
 595         if (GetSocket() == INVALID_SOCKET)
 596         {
 597                 CreateConnection();
 598         }
 599         if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(int)) == -1)
 600         {
 601                 Handler().LogError(this, "SetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 602         }
 603 }
 604
 605
 606 int UdpSocket::GetMulticastTTL()
 607 {
 608         int ttl = 0;
 609         socklen_t size = sizeof(int);
 610
 611         if (GetSocket() == INVALID_SOCKET)
 612         {
 613                 CreateConnection();
 614         }
 615         if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, &size) == -1)
 616         {
 617                 Handler().LogError(this, "GetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 618         }
 619         return ttl;
 620 }
 621
 622
 623 void UdpSocket::SetMulticastLoop(bool x)
 624 {
 625         if (GetSocket() == INVALID_SOCKET)
 626         {
 627                 CreateConnection();
 628         }
 629 #ifdef ENABLE_IPV6
 630 #ifdef IPPROTO_IPV6
 631         if (IsIpv6())
 632         {
 633                 int val = x ? 1 : 0;
 634                 if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
 635                 {
 636                         Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 637                 }
 638                 return;
 639         }
 640 #endif
 641 #endif
 642         int val = x ? 1 : 0;
 643         if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
 644         {
 645                 Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 646         }
 647 }
 648
 649
 650 bool UdpSocket::IsMulticastLoop()
 651 {
 652         if (GetSocket() == INVALID_SOCKET)
 653         {
 654                 CreateConnection();
 655         }
 656 #ifdef ENABLE_IPV6
 657 #ifdef IPPROTO_IPV6
 658         if (IsIpv6())
 659         {
 660                 int is_loop = 0;
 661                 socklen_t size = sizeof(int);
 662                 if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
 663                 {
 664                         Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 665                 }
 666                 return is_loop ? true : false;
 667         }
 668 #endif
 669 #endif
 670         int is_loop = 0;
 671         socklen_t size = sizeof(int);
 672         if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
 673         {
 674                 Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 675         }
 676         return is_loop ? true : false;
 677 }
 678
 679
 680 void UdpSocket::AddMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
 681 {
 682         if (GetSocket() == INVALID_SOCKET)
 683         {
 684                 CreateConnection();
 685         }
 686 #ifdef ENABLE_IPV6
 687 #ifdef IPPROTO_IPV6
 688         if (IsIpv6())
 689         {
 690                 struct ipv6_mreq x;
 691                 struct in6_addr addr;
 692                 if (Utility::u2ip( group, addr ))
 693                 {
 694                         x.ipv6mr_multiaddr = addr;
 695                         x.ipv6mr_interface = if_index;
 696                         if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
 697                         {
 698                                 Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 699                         }
 700                 }
 701                 return;
 702         }
 703 #endif
 704 #endif
 705         struct ip_mreq x; // ip_mreqn
 706         ipaddr_t addr;
 707         if (Utility::u2ip( group, addr ))
 708         {
 709                 memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
 710                 Utility::u2ip( local_if, addr);
 711                 memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
 712 //              x.imr_ifindex = if_index;
 713                 if (setsockopt(GetSocket(), SOL_IP, IP_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
 714                 {
 715                         Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 716                 }
 717         }
 718 }
 719
 720
 721 void UdpSocket::DropMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
 722 {
 723         if (GetSocket() == INVALID_SOCKET)
 724         {
 725                 CreateConnection();
 726         }
 727 #ifdef ENABLE_IPV6
 728 #ifdef IPPROTO_IPV6
 729         if (IsIpv6())
 730         {
 731                 struct ipv6_mreq x;
 732                 struct in6_addr addr;
 733                 if (Utility::u2ip( group, addr ))
 734                 {
 735                         x.ipv6mr_multiaddr = addr;
 736                         x.ipv6mr_interface = if_index;
 737                         if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
 738                         {
 739                                 Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 740                         }
 741                 }
 742                 return;
 743         }
 744 #endif
 745 #endif
 746         struct ip_mreq x; // ip_mreqn
 747         ipaddr_t addr;
 748         if (Utility::u2ip( group, addr ))
 749         {
 750                 memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
 751                 Utility::u2ip( local_if, addr);
 752                 memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
 753 //              x.imr_ifindex = if_index;
 754                 if (setsockopt(GetSocket(), SOL_IP, IP_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
 755                 {
 756                         Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 757                 }
 758         }
 759 }
 760
 761
 762 #ifdef ENABLE_IPV6
 763 #ifdef IPPROTO_IPV6
 764 void UdpSocket::SetMulticastHops(int hops)
 765 {
 766         if (GetSocket() == INVALID_SOCKET)
 767         {
 768                 CreateConnection();
 769         }
 770         if (!IsIpv6())
 771         {
 772                 Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
 773                 return;
 774         }
 775         if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, sizeof(int)) == -1)
 776         {
 777                 Handler().LogError(this, "SetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 778         }
 779 }
 780
 781
 782 int UdpSocket::GetMulticastHops()
 783 {
 784         if (GetSocket() == INVALID_SOCKET)
 785         {
 786                 CreateConnection();
 787         }
 788         if (!IsIpv6())
 789         {
 790                 Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
 791                 return -1;
 792         }
 793         int hops = 0;
 794         socklen_t size = sizeof(int);
 795         if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, &size) == -1)
 796         {
 797                 Handler().LogError(this, "GetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 798         }
 799         return hops;
 800 }
 801 #endif // IPPROTO_IPV6
 802 #endif
 803
 804
 805 bool UdpSocket::IsBound()
 806 {
 807         return m_bind_ok;
 808 }
 809
 810
 811 void UdpSocket::OnRawData(const char *buf, size_t len, struct sockaddr *sa, socklen_t sa_len)
 812 {
 813 }
 814
 815
 816 void UdpSocket::OnRawData(const char *buf, size_t len, struct sockaddr *sa, socklen_t sa_len, struct timeval *ts)
 817 {
 818 }
 819
 820
 821 port_t UdpSocket::GetPort()
 822 {
 823         return m_port;
 824 }
 825
 826
 827 int UdpSocket::GetLastSizeWritten()
 828 {
 829         return m_last_size_written;
 830 }
 831
 832
 833 void UdpSocket::SetTimestamp(bool x)
 834 {
 835         m_b_read_ts = x;
 836 }
 837
 838
 839 #ifdef SOCKETS_NAMESPACE
 840 }
 841 #endif
 842
 843