src/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 #ifndef __MINGW32__
  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 // include this to see strange sights
  45 //#include <linux/in6.h>
  46
  47
  48 #ifdef SOCKETS_NAMESPACE
  49 namespace SOCKETS_NAMESPACE {
  50 #endif
  51
  52
  53 UdpSocket::UdpSocket(ISocketHandler& h, int ibufsz, bool ipv6) : Socket(h)
  54 , m_ibuf(new char[ibufsz])
  55 , m_ibufsz(ibufsz)
  56 , m_bind_ok(false)
  57 , m_port(0)
  58 , m_last_size_written(-1)
  59 {
  60 #ifdef ENABLE_IPV6
  61 #ifdef IPPROTO_IPV6
  62         SetIpv6(ipv6);
  63 #endif
  64 #endif
  65 }
  66
  67
  68 UdpSocket::~UdpSocket()
  69 {
  70         Close();
  71         delete[] m_ibuf;
  72 }
  73
  74
  75 int UdpSocket::Bind(port_t &port, int range)
  76 {
  77 #ifdef ENABLE_IPV6
  78 #ifdef IPPROTO_IPV6
  79         if (IsIpv6())
  80         {
  81                 Ipv6Address ad(port);
  82                 return Bind(ad, range);
  83         }
  84 #endif
  85 #endif
  86         Ipv4Address ad(port);
  87         return Bind(ad, range);
  88 }
  89
  90
  91 int UdpSocket::Bind(const std::string& intf, port_t &port, int range)
  92 {
  93 #ifdef ENABLE_IPV6
  94 #ifdef IPPROTO_IPV6
  95         if (IsIpv6())
  96         {
  97                 Ipv6Address ad(intf, port);
  98                 if (ad.IsValid())
  99                 {
 100                         return Bind(ad, range);
 101                 }
 102                 SetCloseAndDelete();
 103                 return -1;
 104         }
 105 #endif
 106 #endif
 107         Ipv4Address ad(intf, port);
 108         if (ad.IsValid())
 109         {
 110                 return Bind(ad, range);
 111         }
 112         SetCloseAndDelete();
 113         return -1;
 114 }
 115
 116
 117 int UdpSocket::Bind(ipaddr_t a, port_t &port, int range)
 118 {
 119         Ipv4Address ad(a, port);
 120         return Bind(ad, range);
 121 }
 122
 123
 124 #ifdef ENABLE_IPV6
 125 #ifdef IPPROTO_IPV6
 126 int UdpSocket::Bind(in6_addr a, port_t &port, int range)
 127 {
 128         Ipv6Address ad(a, port);
 129         return Bind(ad, range);
 130 }
 131 #endif
 132 #endif
 133
 134
 135 int UdpSocket::Bind(SocketAddress& ad, int range)
 136 {
 137         if (GetSocket() == INVALID_SOCKET)
 138         {
 139                 Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
 140         }
 141         if (GetSocket() != INVALID_SOCKET)
 142         {
 143                 SetNonblocking(true);
 144                 int n = bind(GetSocket(), ad, ad);
 145                 int tries = range;
 146                 while (n == -1 && tries--)
 147                 {
 148                         ad.SetPort(ad.GetPort() + 1);
 149                         n = bind(GetSocket(), ad, ad);
 150                 }
 151                 if (n == -1)
 152                 {
 153                         Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 154                         SetCloseAndDelete();
 155                         return -1;
 156                 }
 157                 m_bind_ok = true;
 158                 m_port = ad.GetPort();
 159                 return 0;
 160         }
 161         return -1;
 162 }
 163
 164
 165 /** if you wish to use Send, first Open a connection */
 166 bool UdpSocket::Open(ipaddr_t l, port_t port)
 167 {
 168         Ipv4Address ad(l, port);
 169         return Open(ad);
 170 }
 171
 172
 173 bool UdpSocket::Open(const std::string& host, port_t port)
 174 {
 175 #ifdef ENABLE_IPV6
 176 #ifdef IPPROTO_IPV6
 177         if (IsIpv6())
 178         {
 179                 Ipv6Address ad(host, port);
 180                 if (ad.IsValid())
 181                 {
 182                         return Open(ad);
 183                 }
 184                 return false;
 185         }
 186 #endif
 187 #endif
 188         Ipv4Address ad(host, port);
 189         if (ad.IsValid())
 190         {
 191                 return Open(ad);
 192         }
 193         return false;
 194 }
 195
 196
 197 #ifdef ENABLE_IPV6
 198 #ifdef IPPROTO_IPV6
 199 bool UdpSocket::Open(struct in6_addr& a, port_t port)
 200 {
 201         Ipv6Address ad(a, port);
 202         return Open(ad);
 203 }
 204 #endif
 205 #endif
 206
 207
 208 bool UdpSocket::Open(SocketAddress& ad)
 209 {
 210         if (GetSocket() == INVALID_SOCKET)
 211         {
 212                 Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
 213         }
 214         if (GetSocket() != INVALID_SOCKET)
 215         {
 216                 SetNonblocking(true);
 217                 if (connect(GetSocket(), ad, ad) == -1)
 218                 {
 219                         Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 220                         SetCloseAndDelete();
 221                         return false;
 222                 }
 223                 SetConnected();
 224                 return true;
 225         }
 226         return false;
 227 }
 228
 229
 230 void UdpSocket::CreateConnection()
 231 {
 232 #ifdef ENABLE_IPV6
 233 #ifdef IPPROTO_IPV6
 234         if (IsIpv6())
 235         {
 236                 if (GetSocket() == INVALID_SOCKET)
 237                 {
 238                         SOCKET s = CreateSocket(AF_INET6, SOCK_DGRAM, "udp");
 239                         if (s == INVALID_SOCKET)
 240                         {
 241                                 return;
 242                         }
 243                         SetNonblocking(true, s);
 244                         Attach(s);
 245                 }
 246                 return;
 247         }
 248 #endif
 249 #endif
 250         if (GetSocket() == INVALID_SOCKET)
 251         {
 252                 SOCKET s = CreateSocket(AF_INET, SOCK_DGRAM, "udp");
 253                 if (s == INVALID_SOCKET)
 254                 {
 255                         return;
 256                 }
 257                 SetNonblocking(true, s);
 258                 Attach(s);
 259         }
 260 }
 261
 262
 263 /** send to specified address */
 264 void UdpSocket::SendToBuf(const std::string& h, port_t p, const char *data, int len, int flags)
 265 {
 266 #ifdef ENABLE_IPV6
 267 #ifdef IPPROTO_IPV6
 268         if (IsIpv6())
 269         {
 270                 Ipv6Address ad(h, p);
 271                 if (ad.IsValid())
 272                 {
 273                         SendToBuf(ad, data, len, flags);
 274                 }
 275                 return;
 276         }
 277 #endif
 278 #endif
 279         Ipv4Address ad(h, p);
 280         if (ad.IsValid())
 281         {
 282                 SendToBuf(ad, data, len, flags);
 283         }
 284 }
 285
 286
 287 /** send to specified address */
 288 void UdpSocket::SendToBuf(ipaddr_t a, port_t p, const char *data, int len, int flags)
 289 {
 290         Ipv4Address ad(a, p);
 291         SendToBuf(ad, data, len, flags);
 292 }
 293
 294
 295 #ifdef ENABLE_IPV6
 296 #ifdef IPPROTO_IPV6
 297 void UdpSocket::SendToBuf(in6_addr a, port_t p, const char *data, int len, int flags)
 298 {
 299         Ipv6Address ad(a, p);
 300         SendToBuf(ad, data, len, flags);
 301 }
 302 #endif
 303 #endif
 304
 305
 306 void UdpSocket::SendToBuf(SocketAddress& ad, const char *data, int len, int flags)
 307 {
 308         if (GetSocket() == INVALID_SOCKET)
 309         {
 310                 Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
 311         }
 312         if (GetSocket() != INVALID_SOCKET)
 313         {
 314                 SetNonblocking(true);
 315                 if ((m_last_size_written = sendto(GetSocket(), data, len, flags, ad, ad)) == -1)
 316                 {
 317                         Handler().LogError(this, "sendto", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 318                 }
 319         }
 320 }
 321
 322
 323 void UdpSocket::SendTo(const std::string& a, port_t p, const std::string& str, int flags)
 324 {
 325         SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 326 }
 327
 328
 329 void UdpSocket::SendTo(ipaddr_t a, port_t p, const std::string& str, int flags)
 330 {
 331         SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 332 }
 333
 334
 335 #ifdef ENABLE_IPV6
 336 #ifdef IPPROTO_IPV6
 337 void UdpSocket::SendTo(in6_addr a, port_t p, const std::string& str, int flags)
 338 {
 339         SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 340 }
 341 #endif
 342 #endif
 343
 344
 345 void UdpSocket::SendTo(SocketAddress& ad, const std::string& str, int flags)
 346 {
 347         SendToBuf(ad, str.c_str(), (int)str.size(), flags);
 348 }
 349
 350
 351 /** send to connected address */
 352 void UdpSocket::SendBuf(const char *data, size_t len, int flags)
 353 {
 354         if (!IsConnected())
 355         {
 356                 Handler().LogError(this, "SendBuf", 0, "not connected", LOG_LEVEL_ERROR);
 357                 return;
 358         }
 359         if ((m_last_size_written = send(GetSocket(), data, (int)len, flags)) == -1)
 360         {
 361                 Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 362         }
 363 }
 364
 365
 366 void UdpSocket::Send(const std::string& str, int flags)
 367 {
 368         SendBuf(str.c_str(), (int)str.size(), flags);
 369 }
 370
 371
 372 void UdpSocket::OnRead()
 373 {
 374 #ifdef ENABLE_IPV6
 375 #ifdef IPPROTO_IPV6
 376         if (IsIpv6())
 377         {
 378                 struct sockaddr_in6 sa;
 379                 socklen_t sa_len = sizeof(sa);
 380                 int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 381                 int q = 10; // receive max 10 at one cycle
 382                 while (n > 0)
 383                 {
 384                         if (sa_len != sizeof(sa))
 385                         {
 386                                 Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
 387                         }
 388                         this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
 389                         if (!q--)
 390                                 break;
 391                         //
 392                         n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 393                 }
 394                 if (n == -1)
 395                 {
 396 #ifdef _WIN32
 397                         if (Errno != WSAEWOULDBLOCK)
 398 #else
 399                         if (Errno != EWOULDBLOCK)
 400 #endif
 401                                 Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 402                 }
 403                 return;
 404         }
 405 #endif
 406 #endif
 407         struct sockaddr_in sa;
 408         socklen_t sa_len = sizeof(sa);
 409         int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 410         int q = 10;
 411         while (n > 0)
 412         {
 413                 if (sa_len != sizeof(sa))
 414                 {
 415                         Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
 416                 }
 417                 this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
 418                 if (!q--)
 419                         break;
 420                 //
 421                 n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 422         }
 423         if (n == -1)
 424         {
 425 #ifdef _WIN32
 426                 if (Errno != WSAEWOULDBLOCK)
 427 #else
 428                 if (Errno != EWOULDBLOCK)
 429 #endif
 430                         Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 431         }
 432 }
 433
 434
 435 void UdpSocket::SetBroadcast(bool b)
 436 {
 437         int one = 1;
 438         int zero = 0;
 439
 440         if (GetSocket() == INVALID_SOCKET)
 441         {
 442                 CreateConnection();
 443         }
 444         if (b)
 445         {
 446                 if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof(one)) == -1)
 447                 {
 448                         Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 449                 }
 450         }
 451         else
 452         {
 453                 if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &zero, sizeof(zero)) == -1)
 454                 {
 455                         Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 456                 }
 457         }
 458 }
 459
 460
 461 bool UdpSocket::IsBroadcast()
 462 {
 463         int is_broadcast = 0;
 464         socklen_t size;
 465
 466         if (GetSocket() == INVALID_SOCKET)
 467         {
 468                 CreateConnection();
 469         }
 470         if (getsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&is_broadcast, &size) == -1)
 471         {
 472                 Handler().LogError(this, "IsBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 473         }
 474         return is_broadcast != 0;
 475 }
 476
 477
 478 void UdpSocket::SetMulticastTTL(int ttl)
 479 {
 480         if (GetSocket() == INVALID_SOCKET)
 481         {
 482                 CreateConnection();
 483         }
 484         if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(int)) == -1)
 485         {
 486                 Handler().LogError(this, "SetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 487         }
 488 }
 489
 490
 491 int UdpSocket::GetMulticastTTL()
 492 {
 493         int ttl = 0;
 494         socklen_t size = sizeof(int);
 495
 496         if (GetSocket() == INVALID_SOCKET)
 497         {
 498                 CreateConnection();
 499         }
 500         if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, &size) == -1)
 501         {
 502                 Handler().LogError(this, "GetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 503         }
 504         return ttl;
 505 }
 506
 507
 508 void UdpSocket::SetMulticastLoop(bool x)
 509 {
 510         if (GetSocket() == INVALID_SOCKET)
 511         {
 512                 CreateConnection();
 513         }
 514 #ifdef ENABLE_IPV6
 515 #ifdef IPPROTO_IPV6
 516         if (IsIpv6())
 517         {
 518                 int val = x ? 1 : 0;
 519                 if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
 520                 {
 521                         Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 522                 }
 523                 return;
 524         }
 525 #endif
 526 #endif
 527         int val = x ? 1 : 0;
 528         if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
 529         {
 530                 Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 531         }
 532 }
 533
 534
 535 bool UdpSocket::IsMulticastLoop()
 536 {
 537         if (GetSocket() == INVALID_SOCKET)
 538         {
 539                 CreateConnection();
 540         }
 541 #ifdef ENABLE_IPV6
 542 #ifdef IPPROTO_IPV6
 543         if (IsIpv6())
 544         {
 545                 int is_loop = 0;
 546                 socklen_t size = sizeof(int);
 547                 if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
 548                 {
 549                         Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 550                 }
 551                 return is_loop ? true : false;
 552         }
 553 #endif
 554 #endif
 555         int is_loop = 0;
 556         socklen_t size = sizeof(int);
 557         if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
 558         {
 559                 Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 560         }
 561         return is_loop ? true : false;
 562 }
 563
 564
 565 void UdpSocket::AddMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
 566 {
 567         if (GetSocket() == INVALID_SOCKET)
 568         {
 569                 CreateConnection();
 570         }
 571 #ifdef ENABLE_IPV6
 572 #ifdef IPPROTO_IPV6
 573         if (IsIpv6())
 574         {
 575                 struct ipv6_mreq x;
 576                 struct in6_addr addr;
 577                 if (Utility::u2ip( group, addr ))
 578                 {
 579                         x.ipv6mr_multiaddr = addr;
 580                         x.ipv6mr_interface = if_index;
 581                         if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
 582                         {
 583                                 Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 584                         }
 585                 }
 586                 return;
 587         }
 588 #endif
 589 #endif
 590         struct ip_mreq x; // ip_mreqn
 591         ipaddr_t addr;
 592         if (Utility::u2ip( group, addr ))
 593         {
 594                 memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
 595                 Utility::u2ip( local_if, addr);
 596                 memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
 597 //              x.imr_ifindex = if_index;
 598                 if (setsockopt(GetSocket(), SOL_IP, IP_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
 599                 {
 600                         Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 601                 }
 602         }
 603 }
 604
 605
 606 void UdpSocket::DropMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
 607 {
 608         if (GetSocket() == INVALID_SOCKET)
 609         {
 610                 CreateConnection();
 611         }
 612 #ifdef ENABLE_IPV6
 613 #ifdef IPPROTO_IPV6
 614         if (IsIpv6())
 615         {
 616                 struct ipv6_mreq x;
 617                 struct in6_addr addr;
 618                 if (Utility::u2ip( group, addr ))
 619                 {
 620                         x.ipv6mr_multiaddr = addr;
 621                         x.ipv6mr_interface = if_index;
 622                         if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
 623                         {
 624                                 Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 625                         }
 626                 }
 627                 return;
 628         }
 629 #endif
 630 #endif
 631         struct ip_mreq x; // ip_mreqn
 632         ipaddr_t addr;
 633         if (Utility::u2ip( group, addr ))
 634         {
 635                 memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
 636                 Utility::u2ip( local_if, addr);
 637                 memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
 638 //              x.imr_ifindex = if_index;
 639                 if (setsockopt(GetSocket(), SOL_IP, IP_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
 640                 {
 641                         Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 642                 }
 643         }
 644 }
 645
 646
 647 #ifdef ENABLE_IPV6
 648 #ifdef IPPROTO_IPV6
 649 void UdpSocket::SetMulticastHops(int hops)
 650 {
 651         if (GetSocket() == INVALID_SOCKET)
 652         {
 653                 CreateConnection();
 654         }
 655         if (!IsIpv6())
 656         {
 657                 Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
 658                 return;
 659         }
 660         if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, sizeof(int)) == -1)
 661         {
 662                 Handler().LogError(this, "SetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 663         }
 664 }
 665
 666
 667 int UdpSocket::GetMulticastHops()
 668 {
 669         if (GetSocket() == INVALID_SOCKET)
 670         {
 671                 CreateConnection();
 672         }
 673         if (!IsIpv6())
 674         {
 675                 Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
 676                 return -1;
 677         }
 678         int hops = 0;
 679         socklen_t size = sizeof(int);
 680         if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, &size) == -1)
 681         {
 682                 Handler().LogError(this, "GetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
 683         }
 684         return hops;
 685 }
 686 #endif // IPPROTO_IPV6
 687 #endif
 688
 689
 690 bool UdpSocket::IsBound()
 691 {
 692         return m_bind_ok;
 693 }
 694
 695
 696 void UdpSocket::OnRawData(const char *buf, size_t len, struct sockaddr *sa, socklen_t sa_len)
 697 {
 698 }
 699
 700
 701 port_t UdpSocket::GetPort()
 702 {
 703         return m_port;
 704 }
 705
 706
 707 int UdpSocket::GetLastSizeWritten()
 708 {
 709         return m_last_size_written;
 710 }
 711
 712
 713 #ifdef SOCKETS_NAMESPACE
 714 }
 715 #endif
 716