src/Sockets/Socket.cpp

   1 /** \file Socket.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 #include "Socket.h"
  31 #ifdef _WIN32
  32 #ifndef __MINGW32__
  33 #pragma warning(disable:4786)
  34 #endif
  35 #include <stdlib.h>
  36 #else
  37 #include <errno.h>
  38 #include <netdb.h>
  39 #endif
  40 #include <ctype.h>
  41 #include <fcntl.h>
  42
  43 #include "ISocketHandler.h"
  44 #include "Utility.h"
  45
  46 #include "SocketAddress.h"
  47 #include "SocketHandler.h"
  48
  49 #ifdef _DEBUG
  50 #define DEB(x) x; fflush(stderr);
  51 #else
  52 #define DEB(x)
  53 #endif
  54
  55 #ifdef SOCKETS_NAMESPACE
  56 namespace SOCKETS_NAMESPACE {
  57 #endif
  58
  59
  60 // statics
  61 #ifdef _WIN32
  62 WSAInitializer Socket::m_winsock_init;
  63 #endif
  64
  65
  66 Socket::Socket(ISocketHandler& h)
  67 //:m_flags(0)
  68 :m_handler(h)
  69 ,m_socket( INVALID_SOCKET )
  70 ,m_bDel(false)
  71 ,m_bClose(false)
  72 ,m_tCreate(time(NULL))
  73 ,m_parent(NULL)
  74 ,m_b_disable_read(false)
  75 ,m_connected(false)
  76 ,m_b_erased_by_handler(false)
  77 ,m_tClose(0)
  78 ,m_client_remote_address(NULL)
  79 ,m_remote_address(NULL)
  80 ,m_traffic_monitor(NULL)
  81 #ifdef HAVE_OPENSSL
  82 ,m_b_enable_ssl(false)
  83 ,m_b_ssl(false)
  84 ,m_b_ssl_server(false)
  85 #endif
  86 #ifdef ENABLE_IPV6
  87 ,m_ipv6(false)
  88 #endif
  89 #ifdef ENABLE_POOL
  90 ,m_socket_type(0)
  91 ,m_bClient(false)
  92 ,m_bRetain(false)
  93 ,m_bLost(false)
  94 #endif
  95 #ifdef ENABLE_SOCKS4
  96 ,m_bSocks4(false)
  97 ,m_socks4_host(h.GetSocks4Host())
  98 ,m_socks4_port(h.GetSocks4Port())
  99 ,m_socks4_userid(h.GetSocks4Userid())
 100 #endif
 101 #ifdef ENABLE_DETACH
 102 ,m_detach(false)
 103 ,m_detached(false)
 104 ,m_pThread(NULL)
 105 ,m_slave_handler(NULL)
 106 #endif
 107 {
 108 }
 109
 110
 111 Socket::~Socket()
 112 {
 113         Handler().Remove(this);
 114         if (m_socket != INVALID_SOCKET
 115 #ifdef ENABLE_POOL
 116                  && !m_bRetain
 117 #endif
 118                 )
 119         {
 120                 Close();
 121         }
 122 }
 123
 124
 125 void Socket::Init()
 126 {
 127 }
 128
 129
 130 void Socket::OnRead()
 131 {
 132 }
 133
 134
 135 void Socket::OnWrite()
 136 {
 137 }
 138
 139
 140 void Socket::OnException()
 141 {
 142         // %! exception doesn't always mean something bad happened, this code should be reworked
 143         // errno valid here?
 144         int err = SoError();
 145         Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
 146         SetCloseAndDelete();
 147 }
 148
 149
 150 void Socket::OnDelete()
 151 {
 152 }
 153
 154
 155 void Socket::OnConnect()
 156 {
 157 }
 158
 159
 160 void Socket::OnAccept()
 161 {
 162 }
 163
 164
 165 int Socket::Close()
 166 {
 167         if (m_socket == INVALID_SOCKET) // this could happen
 168         {
 169                 Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
 170                 return 0;
 171         }
 172         int n;
 173         if ((n = closesocket(m_socket)) == -1)
 174         {
 175                 // failed...
 176                 Handler().LogError(this, "close", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 177         }
 178         Handler().Set(m_socket, false, false, false); // remove from fd_set's
 179         Handler().AddList(m_socket, LIST_CALLONCONNECT, false);
 180 #ifdef ENABLE_DETACH
 181         Handler().AddList(m_socket, LIST_DETACH, false);
 182 #endif
 183         Handler().AddList(m_socket, LIST_TIMEOUT, false);
 184         Handler().AddList(m_socket, LIST_RETRY, false);
 185         Handler().AddList(m_socket, LIST_CLOSE, false);
 186         m_socket = INVALID_SOCKET;
 187         return n;
 188 }
 189
 190
 191 SOCKET Socket::CreateSocket(int af,int type, const std::string& protocol)
 192 {
 193         struct protoent *p = NULL;
 194         SOCKET s;
 195
 196 #ifdef ENABLE_POOL
 197         m_socket_type = type;
 198         m_socket_protocol = protocol;
 199 #endif
 200         if (protocol.size())
 201         {
 202                 p = getprotobyname( protocol.c_str() );
 203                 if (!p)
 204                 {
 205                         Handler().LogError(this, "getprotobyname", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 206                         SetCloseAndDelete();
 207                         return INVALID_SOCKET;
 208                 }
 209         }
 210         int protno = p ? p -> p_proto : 0;
 211
 212         s = socket(af, type, protno);
 213         if (s == INVALID_SOCKET)
 214         {
 215                 Handler().LogError(this, "socket", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 216                 SetCloseAndDelete();
 217                 return INVALID_SOCKET;
 218         }
 219         Attach(s);
 220         OnOptions(af, type, protno, s);
 221         Attach(INVALID_SOCKET);
 222         return s;
 223 }
 224
 225
 226 void Socket::Attach(SOCKET s)
 227 {
 228         m_socket = s;
 229 }
 230
 231
 232 SOCKET Socket::GetSocket()
 233 {
 234         return m_socket;
 235 }
 236
 237
 238 void Socket::SetDeleteByHandler(bool x)
 239 {
 240         m_bDel = x;
 241 }
 242
 243
 244 bool Socket::DeleteByHandler()
 245 {
 246         return m_bDel;
 247 }
 248
 249
 250 void Socket::SetCloseAndDelete(bool x)
 251 {
 252         if (x != m_bClose)
 253         {
 254                 Handler().AddList(m_socket, LIST_CLOSE, x);
 255                 m_bClose = x;
 256                 if (x)
 257                 {
 258                         m_tClose = time(NULL);
 259                 }
 260         }
 261 }
 262
 263
 264 bool Socket::CloseAndDelete()
 265 {
 266         return m_bClose;
 267 }
 268
 269
 270 void Socket::SetRemoteAddress(SocketAddress& ad) //struct sockaddr* sa, socklen_t l)
 271 {
 272         m_remote_address = ad.GetCopy();
 273 }
 274
 275
 276 std::auto_ptr<SocketAddress> Socket::GetRemoteSocketAddress()
 277 {
 278         return std::auto_ptr<SocketAddress>(m_remote_address -> GetCopy());
 279 }
 280
 281
 282 ISocketHandler& Socket::Handler() const
 283 {
 284 #ifdef ENABLE_DETACH
 285         if (IsDetached())
 286                 return *m_slave_handler;
 287 #endif
 288         return m_handler;
 289 }
 290
 291
 292 ISocketHandler& Socket::MasterHandler() const
 293 {
 294         return m_handler;
 295 }
 296
 297
 298 ipaddr_t Socket::GetRemoteIP4()
 299 {
 300         ipaddr_t l = 0;
 301 #ifdef ENABLE_IPV6
 302         if (m_ipv6)
 303         {
 304                 Handler().LogError(this, "GetRemoteIP4", 0, "get ipv4 address for ipv6 socket", LOG_LEVEL_WARNING);
 305         }
 306 #endif
 307         if (m_remote_address.get() != NULL)
 308         {
 309                 struct sockaddr *p = *m_remote_address;
 310                 struct sockaddr_in *sa = (struct sockaddr_in *)p;
 311                 memcpy(&l, &sa -> sin_addr, sizeof(struct in_addr));
 312         }
 313         return l;
 314 }
 315
 316
 317 #ifdef ENABLE_IPV6
 318 #ifdef IPPROTO_IPV6
 319 struct in6_addr Socket::GetRemoteIP6()
 320 {
 321         if (!m_ipv6)
 322         {
 323                 Handler().LogError(this, "GetRemoteIP6", 0, "get ipv6 address for ipv4 socket", LOG_LEVEL_WARNING);
 324         }
 325         struct sockaddr_in6 fail;
 326         if (m_remote_address.get() != NULL)
 327         {
 328                 struct sockaddr *p = *m_remote_address;
 329                 memcpy(&fail, p, sizeof(struct sockaddr_in6));
 330         }
 331         else
 332         {
 333                 memset(&fail, 0, sizeof(struct sockaddr_in6));
 334         }
 335         return fail.sin6_addr;
 336 }
 337 #endif
 338 #endif
 339
 340
 341 port_t Socket::GetRemotePort()
 342 {
 343         if (!m_remote_address.get())
 344         {
 345                 return 0;
 346         }
 347         return m_remote_address -> GetPort();
 348 }
 349
 350
 351 std::string Socket::GetRemoteAddress()
 352 {
 353         if (!m_remote_address.get())
 354         {
 355                 return "";
 356         }
 357         return m_remote_address -> Convert(false);
 358 }
 359
 360
 361 std::string Socket::GetRemoteHostname()
 362 {
 363         if (!m_remote_address.get())
 364         {
 365                 return "";
 366         }
 367         return m_remote_address -> Reverse();
 368 }
 369
 370
 371 bool Socket::SetNonblocking(bool bNb)
 372 {
 373 #ifdef _WIN32
 374         unsigned long l = bNb ? 1 : 0;
 375         int n = ioctlsocket(m_socket, FIONBIO, &l);
 376         if (n != 0)
 377         {
 378                 Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
 379                 return false;
 380         }
 381         return true;
 382 #else
 383         if (bNb)
 384         {
 385                 if (fcntl(m_socket, F_SETFL, O_NONBLOCK) == -1)
 386                 {
 387                         Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 388                         return false;
 389                 }
 390         }
 391         else
 392         {
 393                 if (fcntl(m_socket, F_SETFL, 0) == -1)
 394                 {
 395                         Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 396                         return false;
 397                 }
 398         }
 399         return true;
 400 #endif
 401 }
 402
 403
 404 bool Socket::SetNonblocking(bool bNb, SOCKET s)
 405 {
 406 #ifdef _WIN32
 407         unsigned long l = bNb ? 1 : 0;
 408         int n = ioctlsocket(s, FIONBIO, &l);
 409         if (n != 0)
 410         {
 411                 Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
 412                 return false;
 413         }
 414         return true;
 415 #else
 416         if (bNb)
 417         {
 418                 if (fcntl(s, F_SETFL, O_NONBLOCK) == -1)
 419                 {
 420                         Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 421                         return false;
 422                 }
 423         }
 424         else
 425         {
 426                 if (fcntl(s, F_SETFL, 0) == -1)
 427                 {
 428                         Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
 429                         return false;
 430                 }
 431         }
 432         return true;
 433 #endif
 434 }
 435
 436
 437 void Socket::Set(bool bRead, bool bWrite, bool bException)
 438 {
 439         Handler().Set(m_socket, bRead, bWrite, bException);
 440 }
 441
 442
 443 bool Socket::Ready()
 444 {
 445         if (m_socket != INVALID_SOCKET && !CloseAndDelete())
 446                 return true;
 447         return false;
 448 }
 449
 450
 451 void Socket::OnLine(const std::string& )
 452 {
 453 }
 454
 455
 456 void Socket::OnConnectFailed()
 457 {
 458 }
 459
 460
 461 Socket *Socket::GetParent()
 462 {
 463         return m_parent;
 464 }
 465
 466
 467 void Socket::SetParent(Socket *x)
 468 {
 469         m_parent = x;
 470 }
 471
 472
 473 port_t Socket::GetPort()
 474 {
 475         Handler().LogError(this, "GetPort", 0, "GetPort only implemented for ListenSocket", LOG_LEVEL_WARNING);
 476         return 0;
 477 }
 478
 479
 480 bool Socket::OnConnectRetry()
 481 {
 482         return true;
 483 }
 484
 485
 486 #ifdef ENABLE_RECONNECT
 487 void Socket::OnReconnect()
 488 {
 489 }
 490 #endif
 491
 492
 493 time_t Socket::Uptime()
 494 {
 495         return time(NULL) - m_tCreate;
 496 }
 497
 498
 499 #ifdef ENABLE_IPV6
 500 void Socket::SetIpv6(bool x)
 501 {
 502         m_ipv6 = x;
 503 }
 504
 505
 506 bool Socket::IsIpv6()
 507 {
 508         return m_ipv6;
 509 }
 510 #endif
 511
 512
 513 void Socket::DisableRead(bool x)
 514 {
 515         m_b_disable_read = x;
 516 }
 517
 518
 519 bool Socket::IsDisableRead()
 520 {
 521         return m_b_disable_read;
 522 }
 523
 524
 525 void Socket::SendBuf(const char *,size_t,int)
 526 {
 527 }
 528
 529
 530 void Socket::Send(const std::string&,int)
 531 {
 532 }
 533
 534
 535 void Socket::SetConnected(bool x)
 536 {
 537         m_connected = x;
 538 }
 539
 540
 541 bool Socket::IsConnected()
 542 {
 543         return m_connected;
 544 }
 545
 546
 547 #ifdef ENABLE_RECONNECT
 548 void Socket::OnDisconnect()
 549 {
 550 }
 551 #endif
 552
 553
 554 void Socket::SetErasedByHandler(bool x)
 555 {
 556         m_b_erased_by_handler = x;
 557 }
 558
 559
 560 bool Socket::ErasedByHandler()
 561 {
 562         return m_b_erased_by_handler;
 563 }
 564
 565
 566 time_t Socket::TimeSinceClose()
 567 {
 568         return time(NULL) - m_tClose;
 569 }
 570
 571
 572 void Socket::SetClientRemoteAddress(SocketAddress& ad)
 573 {
 574         if (!ad.IsValid())
 575         {
 576                 Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);
 577         }
 578         m_client_remote_address = ad.GetCopy();
 579 }
 580
 581
 582 std::auto_ptr<SocketAddress> Socket::GetClientRemoteAddress()
 583 {
 584         if (!m_client_remote_address.get())
 585         {
 586                 Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);
 587         }
 588         return std::auto_ptr<SocketAddress>(m_client_remote_address -> GetCopy());
 589 }
 590
 591
 592 uint64_t Socket::GetBytesSent(bool)
 593 {
 594         return 0;
 595 }
 596
 597
 598 uint64_t Socket::GetBytesReceived(bool)
 599 {
 600         return 0;
 601 }
 602
 603
 604 #ifdef HAVE_OPENSSL
 605 void Socket::OnSSLConnect()
 606 {
 607 }
 608
 609
 610 void Socket::OnSSLAccept()
 611 {
 612 }
 613
 614
 615 bool Socket::SSLNegotiate()
 616 {
 617         return false;
 618 }
 619
 620
 621 bool Socket::IsSSL()
 622 {
 623         return m_b_enable_ssl;
 624 }
 625
 626
 627 void Socket::EnableSSL(bool x)
 628 {
 629         m_b_enable_ssl = x;
 630 }
 631
 632
 633 bool Socket::IsSSLNegotiate()
 634 {
 635         return m_b_ssl;
 636 }
 637
 638
 639 void Socket::SetSSLNegotiate(bool x)
 640 {
 641         m_b_ssl = x;
 642 }
 643
 644
 645 bool Socket::IsSSLServer()
 646 {
 647         return m_b_ssl_server;
 648 }
 649
 650
 651 void Socket::SetSSLServer(bool x)
 652 {
 653         m_b_ssl_server = x;
 654 }
 655
 656
 657 void Socket::OnSSLConnectFailed()
 658 {
 659 }
 660
 661
 662 void Socket::OnSSLAcceptFailed()
 663 {
 664 }
 665 #endif // HAVE_OPENSSL
 666
 667
 668 #ifdef ENABLE_POOL
 669 void Socket::CopyConnection(Socket *sock)
 670 {
 671         Attach( sock -> GetSocket() );
 672 #ifdef ENABLE_IPV6
 673         SetIpv6( sock -> IsIpv6() );
 674 #endif
 675         SetSocketType( sock -> GetSocketType() );
 676         SetSocketProtocol( sock -> GetSocketProtocol() );
 677
 678         SetClientRemoteAddress( *sock -> GetClientRemoteAddress() );
 679         SetRemoteAddress( *sock -> GetRemoteSocketAddress() );
 680 }
 681
 682
 683 void Socket::SetIsClient()
 684 {
 685         m_bClient = true;
 686 }
 687
 688
 689 void Socket::SetSocketType(int x)
 690 {
 691         m_socket_type = x;
 692 }
 693
 694
 695 int Socket::GetSocketType()
 696 {
 697         return m_socket_type;
 698 }
 699
 700
 701 void Socket::SetSocketProtocol(const std::string& x)
 702 {
 703         m_socket_protocol = x;
 704 }
 705
 706
 707 const std::string& Socket::GetSocketProtocol()
 708 {
 709         return m_socket_protocol;
 710 }
 711
 712
 713 void Socket::SetRetain()
 714 {
 715         if (m_bClient) m_bRetain = true;
 716 }
 717
 718
 719 bool Socket::Retain()
 720 {
 721         return m_bRetain;
 722 }
 723
 724
 725 void Socket::SetLost()
 726 {
 727         m_bLost = true;
 728 }
 729
 730
 731 bool Socket::Lost()
 732 {
 733         return m_bLost;
 734 }
 735 #endif // ENABLE_POOL
 736
 737
 738 #ifdef ENABLE_SOCKS4
 739 void Socket::OnSocks4Connect()
 740 {
 741         Handler().LogError(this, "OnSocks4Connect", 0, "Use with TcpSocket only");
 742 }
 743
 744
 745 void Socket::OnSocks4ConnectFailed()
 746 {
 747         Handler().LogError(this, "OnSocks4ConnectFailed", 0, "Use with TcpSocket only");
 748 }
 749
 750
 751 bool Socket::OnSocks4Read()
 752 {
 753         Handler().LogError(this, "OnSocks4Read", 0, "Use with TcpSocket only");
 754         return true;
 755 }
 756
 757
 758 void Socket::SetSocks4Host(const std::string& host)
 759 {
 760         Utility::u2ip(host, m_socks4_host);
 761 }
 762
 763
 764 bool Socket::Socks4()
 765 {
 766         return m_bSocks4;
 767 }
 768
 769
 770 void Socket::SetSocks4(bool x)
 771 {
 772         m_bSocks4 = x;
 773 }
 774
 775
 776 void Socket::SetSocks4Host(ipaddr_t a)
 777 {
 778         m_socks4_host = a;
 779 }
 780
 781
 782 void Socket::SetSocks4Port(port_t p)
 783 {
 784         m_socks4_port = p;
 785 }
 786
 787
 788 void Socket::SetSocks4Userid(const std::string& x)
 789 {
 790         m_socks4_userid = x;
 791 }
 792
 793
 794 ipaddr_t Socket::GetSocks4Host()
 795 {
 796         return m_socks4_host;
 797 }
 798
 799
 800 port_t Socket::GetSocks4Port()
 801 {
 802         return m_socks4_port;
 803 }
 804
 805
 806 const std::string& Socket::GetSocks4Userid()
 807 {
 808         return m_socks4_userid;
 809 }
 810 #endif // ENABLE_SOCKS4
 811
 812
 813 #ifdef ENABLE_DETACH
 814 bool Socket::Detach()
 815 {
 816         if (!DeleteByHandler())
 817                 return false;
 818         if (m_pThread)
 819                 return false;
 820         if (m_detached)
 821                 return false;
 822         SetDetach();
 823         return true;
 824 }
 825
 826
 827 void Socket::DetachSocket()
 828 {
 829         SetDetached();
 830         m_pThread = new SocketThread(this);
 831         m_pThread -> SetRelease(true);
 832 }
 833
 834
 835 void Socket::OnDetached()
 836 {
 837 }
 838
 839
 840 void Socket::SetDetach(bool x)
 841 {
 842         Handler().AddList(m_socket, LIST_DETACH, x);
 843         m_detach = x;
 844 }
 845
 846
 847 bool Socket::IsDetach()
 848 {
 849         return m_detach;
 850 }
 851
 852
 853 void Socket::SetDetached(bool x)
 854 {
 855         m_detached = x;
 856 }
 857
 858
 859 const bool Socket::IsDetached() const
 860 {
 861         return m_detached;
 862 }
 863
 864
 865 void Socket::SetSlaveHandler(ISocketHandler *p)
 866 {
 867         m_slave_handler = p;
 868 }
 869
 870
 871 Socket::SocketThread::SocketThread(Socket *p)
 872 :Thread(false)
 873 ,m_socket(p)
 874 {
 875         // Creator will release
 876 }
 877
 878
 879 Socket::SocketThread::~SocketThread()
 880 {
 881         if (IsRunning())
 882         {
 883                 SetRelease(true);
 884                 SetRunning(false);
 885 #ifdef _WIN32
 886                 Sleep(1000);
 887 #else
 888                 sleep(1);
 889 #endif
 890         }
 891 }
 892
 893
 894 void Socket::SocketThread::Run()
 895 {
 896         SocketHandler h;
 897         h.SetSlave();
 898         h.Add(m_socket);
 899         m_socket -> SetSlaveHandler(&h);
 900         m_socket -> OnDetached();
 901         while (h.GetCount() && IsRunning())
 902         {
 903                 h.Select(0, 500000);
 904         }
 905         // m_socket now deleted oops
 906         // yeah oops m_socket delete its socket thread, that means this
 907         // so Socket will no longer delete its socket thread, instead we do this:
 908         SetDeleteOnExit();
 909 }
 910 #endif // ENABLE_DETACH
 911
 912
 913 #ifdef ENABLE_RESOLVER
 914 int Socket::Resolve(const std::string& host,port_t port)
 915 {
 916         return Handler().Resolve(this, host, port);
 917 }
 918
 919
 920 #ifdef ENABLE_IPV6
 921 int Socket::Resolve6(const std::string& host,port_t port)
 922 {
 923         return Handler().Resolve6(this, host, port);
 924 }
 925 #endif
 926
 927
 928 int Socket::Resolve(ipaddr_t a)
 929 {
 930         return Handler().Resolve(this, a);
 931 }
 932
 933
 934 #ifdef ENABLE_IPV6
 935 int Socket::Resolve(in6_addr& a)
 936 {
 937         return Handler().Resolve(this, a);
 938 }
 939 #endif
 940
 941
 942 void Socket::OnResolved(int,ipaddr_t,port_t)
 943 {
 944 }
 945
 946
 947 #ifdef ENABLE_IPV6
 948 void Socket::OnResolved(int,in6_addr&,port_t)
 949 {
 950 }
 951 #endif
 952
 953
 954 void Socket::OnReverseResolved(int,const std::string&)
 955 {
 956 }
 957
 958
 959 void Socket::OnResolveFailed(int)
 960 {
 961 }
 962 #endif // ENABLE_RESOLVER
 963
 964
 965 /* IP options */
 966
 967
 968 bool Socket::SetIpOptions(const void *p, socklen_t len)
 969 {
 970 #ifdef IP_OPTIONS
 971         if (setsockopt(GetSocket(), IPPROTO_IP, IP_OPTIONS, (char *)p, len) == -1)
 972         {
 973                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_OPTIONS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 974                 return false;
 975         }
 976         return true;
 977 #else
 978         Handler().LogError(this, "ip option not available", 0, "IP_OPTIONS", LOG_LEVEL_INFO);
 979         return false;
 980 #endif
 981 }
 982
 983
 984 #ifdef IP_PKTINFO
 985 bool Socket::SetIpPktinfo(bool x)
 986 {
 987         int optval = x ? 1 : 0;
 988         if (setsockopt(GetSocket(), IPPROTO_IP, IP_PKTINFO, (char *)&optval, sizeof(optval)) == -1)
 989         {
 990                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_PKTINFO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
 991                 return false;
 992         }
 993         return true;
 994 }
 995 #endif
 996
 997
 998 #ifdef IP_RECVTOS
 999 bool Socket::SetIpRecvTOS(bool x)
1000 {
1001         int optval = x ? 1 : 0;
1002         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTOS, (char *)&optval, sizeof(optval)) == -1)
1003         {
1004                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1005                 return false;
1006         }
1007         return true;
1008 }
1009 #endif
1010
1011
1012 #ifdef IP_RECVTTL
1013 bool Socket::SetIpRecvTTL(bool x)
1014 {
1015         int optval = x ? 1 : 0;
1016         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTTL, (char *)&optval, sizeof(optval)) == -1)
1017         {
1018                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1019                 return false;
1020         }
1021         return true;
1022 }
1023 #endif
1024
1025
1026 #ifdef IP_RECVOPTS
1027 bool Socket::SetIpRecvopts(bool x)
1028 {
1029         int optval = x ? 1 : 0;
1030         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVOPTS, (char *)&optval, sizeof(optval)) == -1)
1031         {
1032                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1033                 return false;
1034         }
1035         return true;
1036 }
1037 #endif
1038
1039
1040 #ifdef IP_RETOPTS
1041 bool Socket::SetIpRetopts(bool x)
1042 {
1043         int optval = x ? 1 : 0;
1044         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RETOPTS, (char *)&optval, sizeof(optval)) == -1)
1045         {
1046                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RETOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1047                 return false;
1048         }
1049         return true;
1050 }
1051 #endif
1052
1053
1054 bool Socket::SetIpTOS(unsigned char tos)
1055 {
1056 #ifdef IP_TOS
1057         if (setsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(tos)) == -1)
1058         {
1059                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1060                 return false;
1061         }
1062         return true;
1063 #else
1064         Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
1065         return false;
1066 #endif
1067 }
1068
1069
1070 unsigned char Socket::IpTOS()
1071 {
1072         unsigned char tos = 0;
1073 #ifdef IP_TOS
1074         socklen_t len = sizeof(tos);
1075         if (getsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, &len) == -1)
1076         {
1077                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1078         }
1079 #else
1080         Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
1081 #endif
1082         return tos;
1083 }
1084
1085
1086 bool Socket::SetIpTTL(int ttl)
1087 {
1088 #ifdef IP_TTL
1089         if (setsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl)) == -1)
1090         {
1091                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1092                 return false;
1093         }
1094         return true;
1095 #else
1096         Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
1097         return false;
1098 #endif
1099 }
1100
1101
1102 int Socket::IpTTL()
1103 {
1104         int ttl = 0;
1105 #ifdef IP_TTL
1106         socklen_t len = sizeof(ttl);
1107         if (getsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, &len) == -1)
1108         {
1109                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1110         }
1111 #else
1112         Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
1113 #endif
1114         return ttl;
1115 }
1116
1117
1118 bool Socket::SetIpHdrincl(bool x)
1119 {
1120 #ifdef IP_HDRINCL
1121         int optval = x ? 1 : 0;
1122         if (setsockopt(GetSocket(), IPPROTO_IP, IP_HDRINCL, (char *)&optval, sizeof(optval)) == -1)
1123         {
1124                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_HDRINCL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1125                 return false;
1126         }
1127         return true;
1128 #else
1129         Handler().LogError(this, "ip option not available", 0, "IP_HDRINCL", LOG_LEVEL_INFO);
1130         return false;
1131 #endif
1132 }
1133
1134
1135 #ifdef IP_RECVERR
1136 bool Socket::SetIpRecverr(bool x)
1137 {
1138         int optval = x ? 1 : 0;
1139         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVERR, (char *)&optval, sizeof(optval)) == -1)
1140         {
1141                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVERR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1142                 return false;
1143         }
1144         return true;
1145 }
1146 #endif
1147
1148
1149 #ifdef IP_MTU_DISCOVER
1150 bool Socket::SetIpMtudiscover(bool x)
1151 {
1152         int optval = x ? 1 : 0;
1153         if (setsockopt(GetSocket(), IPPROTO_IP, IP_MTU_DISCOVER, (char *)&optval, sizeof(optval)) == -1)
1154         {
1155                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MTU_DISCOVER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1156                 return false;
1157         }
1158         return true;
1159 }
1160 #endif
1161
1162
1163 #ifdef IP_MTU
1164 int Socket::IpMtu()
1165 {
1166         int mtu = 0;
1167         socklen_t len = sizeof(mtu);
1168         if (getsockopt(GetSocket(), IPPROTO_IP, IP_MTU, (char *)&mtu, &len) == -1)
1169         {
1170                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MTU)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1171         }
1172         return mtu;
1173 }
1174 #endif
1175
1176
1177 #ifdef IP_ROUTER_ALERT
1178 bool Socket::SetIpRouterAlert(bool x)
1179 {
1180         int optval = x ? 1 : 0;
1181         if (setsockopt(GetSocket(), IPPROTO_IP, IP_ROUTER_ALERT, (char *)&optval, sizeof(optval)) == -1)
1182         {
1183                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ROUTER_ALERT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1184                 return false;
1185         }
1186         return true;
1187 }
1188 #endif
1189
1190
1191 bool Socket::SetIpMulticastTTL(int ttl)
1192 {
1193 #ifdef IP_MULTICAST_TTL
1194         if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(ttl)) == -1)
1195         {
1196                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1197                 return false;
1198         }
1199         return true;
1200 #else
1201         Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
1202         return false;
1203 #endif
1204 }
1205
1206
1207 int Socket::IpMulticastTTL()
1208 {
1209         int ttl = 0;
1210 #ifdef IP_MULTICAST_TTL
1211         socklen_t len = sizeof(ttl);
1212         if (getsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, &len) == -1)
1213         {
1214                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1215         }
1216 #else
1217         Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
1218 #endif
1219         return ttl;
1220 }
1221
1222
1223 bool Socket::SetMulticastLoop(bool x)
1224 {
1225 #ifdef IP_MULTICAST_LOOP
1226         int optval = x ? 1 : 0;
1227         if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&optval, sizeof(optval)) == -1)
1228         {
1229                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_LOOP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1230                 return false;
1231         }
1232         return true;
1233 #else
1234         Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_LOOP", LOG_LEVEL_INFO);
1235         return false;
1236 #endif
1237 }
1238
1239
1240 #ifdef LINUX
1241 bool Socket::IpAddMembership(struct ip_mreqn& ref)
1242 {
1243 #ifdef IP_ADD_MEMBERSHIP
1244         if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
1245         {
1246                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1247                 return false;
1248         }
1249         return true;
1250 #else
1251         Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
1252         return false;
1253 #endif
1254 }
1255 #endif
1256
1257
1258 bool Socket::IpAddMembership(struct ip_mreq& ref)
1259 {
1260 #ifdef IP_ADD_MEMBERSHIP
1261         if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
1262         {
1263                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1264                 return false;
1265         }
1266         return true;
1267 #else
1268         Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
1269         return false;
1270 #endif
1271 }
1272
1273
1274 #ifdef LINUX
1275 bool Socket::IpDropMembership(struct ip_mreqn& ref)
1276 {
1277 #ifdef IP_DROP_MEMBERSHIP
1278         if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
1279         {
1280                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1281                 return false;
1282         }
1283         return true;
1284 #else
1285         Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
1286         return false;
1287 #endif
1288 }
1289 #endif
1290
1291
1292 bool Socket::IpDropMembership(struct ip_mreq& ref)
1293 {
1294 #ifdef IP_DROP_MEMBERSHIP
1295         if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
1296         {
1297                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1298                 return false;
1299         }
1300         return true;
1301 #else
1302         Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
1303         return false;
1304 #endif
1305 }
1306
1307
1308 /* SOCKET options */
1309
1310
1311 bool Socket::SetSoReuseaddr(bool x)
1312 {
1313 #ifdef SO_REUSEADDR
1314         int optval = x ? 1 : 0;
1315         if (setsockopt(GetSocket(), SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) == -1)
1316         {
1317                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_REUSEADDR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1318                 return false;
1319         }
1320         return true;
1321 #else
1322         Handler().LogError(this, "socket option not available", 0, "SO_REUSEADDR", LOG_LEVEL_INFO);
1323         return false;
1324 #endif
1325 }
1326
1327
1328 bool Socket::SetSoKeepalive(bool x)
1329 {
1330 #ifdef SO_KEEPALIVE
1331         int optval = x ? 1 : 0;
1332         if (setsockopt(GetSocket(), SOL_SOCKET, SO_KEEPALIVE, (char *)&optval, sizeof(optval)) == -1)
1333         {
1334                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_KEEPALIVE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1335                 return false;
1336         }
1337         return true;
1338 #else
1339         Handler().LogError(this, "socket option not available", 0, "SO_KEEPALIVE", LOG_LEVEL_INFO);
1340         return false;
1341 #endif
1342 }
1343
1344
1345 #ifdef SO_NOSIGPIPE
1346 bool Socket::SetSoNosigpipe(bool x)
1347 {
1348         int optval = x ? 1 : 0;
1349         if (setsockopt(GetSocket(), SOL_SOCKET, SO_NOSIGPIPE, (char *)&optval, sizeof(optval)) == -1)
1350         {
1351                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_NOSIGPIPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1352                 return false;
1353         }
1354         return true;
1355 }
1356 #endif
1357
1358
1359 bool Socket::SoAcceptconn()
1360 {
1361         int value = 0;
1362 #ifdef SO_ACCEPTCONN
1363         socklen_t len = sizeof(value);
1364         if (getsockopt(GetSocket(), SOL_SOCKET, SO_ACCEPTCONN, (char *)&value, &len) == -1)
1365         {
1366                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_ACCEPTCONN)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1367         }
1368 #else
1369         Handler().LogError(this, "socket option not available", 0, "SO_ACCEPTCONN", LOG_LEVEL_INFO);
1370 #endif
1371         return value ? true : false;
1372 }
1373
1374
1375 #ifdef SO_BSDCOMPAT
1376 bool Socket::SetSoBsdcompat(bool x)
1377 {
1378         int optval = x ? 1 : 0;
1379         if (setsockopt(GetSocket(), SOL_SOCKET, SO_BSDCOMPAT, (char *)&optval, sizeof(optval)) == -1)
1380         {
1381                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BSDCOMPAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1382                 return false;
1383         }
1384         return true;
1385 }
1386 #endif
1387
1388
1389 #ifdef SO_BINDTODEVICE
1390 bool Socket::SetSoBindtodevice(const std::string& intf)
1391 {
1392         if (setsockopt(GetSocket(), SOL_SOCKET, SO_BINDTODEVICE, (char *)intf.c_str(), intf.size()) == -1)
1393         {
1394                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BINDTODEVICE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1395                 return false;
1396         }
1397         return true;
1398 }
1399 #endif
1400
1401
1402 bool Socket::SetSoBroadcast(bool x)
1403 {
1404 #ifdef SO_BROADCAST
1405         int optval = x ? 1 : 0;
1406         if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) == -1)
1407         {
1408                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BROADCAST)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1409                 return false;
1410         }
1411         return true;
1412 #else
1413         Handler().LogError(this, "socket option not available", 0, "SO_BROADCAST", LOG_LEVEL_INFO);
1414         return false;
1415 #endif
1416 }
1417
1418
1419 bool Socket::SetSoDebug(bool x)
1420 {
1421 #ifdef SO_DEBUG
1422         int optval = x ? 1 : 0;
1423         if (setsockopt(GetSocket(), SOL_SOCKET, SO_DEBUG, (char *)&optval, sizeof(optval)) == -1)
1424         {
1425                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DEBUG)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1426                 return false;
1427         }
1428         return true;
1429 #else
1430         Handler().LogError(this, "socket option not available", 0, "SO_DEBUG", LOG_LEVEL_INFO);
1431         return false;
1432 #endif
1433 }
1434
1435
1436 int Socket::SoError()
1437 {
1438         int value = 0;
1439 #ifdef SO_ERROR
1440         socklen_t len = sizeof(value);
1441         if (getsockopt(GetSocket(), SOL_SOCKET, SO_ERROR, (char *)&value, &len) == -1)
1442         {
1443                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_ERROR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1444         }
1445 #else
1446         Handler().LogError(this, "socket option not available", 0, "SO_ERROR", LOG_LEVEL_INFO);
1447 #endif
1448         return value ? true : false;
1449 }
1450
1451
1452 bool Socket::SetSoDontroute(bool x)
1453 {
1454 #ifdef SO_DONTROUTE
1455         int optval = x ? 1 : 0;
1456         if (setsockopt(GetSocket(), SOL_SOCKET, SO_DONTROUTE, (char *)&optval, sizeof(optval)) == -1)
1457         {
1458                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DONTROUTE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1459                 return false;
1460         }
1461         return true;
1462 #else
1463         Handler().LogError(this, "socket option not available", 0, "SO_DONTROUTE", LOG_LEVEL_INFO);
1464         return false;
1465 #endif
1466 }
1467
1468
1469 bool Socket::SetSoLinger(int onoff, int linger)
1470 {
1471 #ifdef SO_LINGER
1472         struct linger stl;
1473         stl.l_onoff = onoff;
1474         stl.l_linger = linger;
1475         if (setsockopt(GetSocket(), SOL_SOCKET, SO_LINGER, (char *)&stl, sizeof(stl)) == -1)
1476         {
1477                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_LINGER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1478                 return false;
1479         }
1480         return true;
1481 #else
1482         Handler().LogError(this, "socket option not available", 0, "SO_LINGER", LOG_LEVEL_INFO);
1483         return false;
1484 #endif
1485 }
1486
1487
1488 bool Socket::SetSoOobinline(bool x)
1489 {
1490 #ifdef SO_OOBINLINE
1491         int optval = x ? 1 : 0;
1492         if (setsockopt(GetSocket(), SOL_SOCKET, SO_OOBINLINE, (char *)&optval, sizeof(optval)) == -1)
1493         {
1494                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_OOBINLINE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1495                 return false;
1496         }
1497         return true;
1498 #else
1499         Handler().LogError(this, "socket option not available", 0, "SO_OOBINLINE", LOG_LEVEL_INFO);
1500         return false;
1501 #endif
1502 }
1503
1504
1505 #ifdef SO_PASSCRED
1506 bool Socket::SetSoPasscred(bool x)
1507 {
1508         int optval = x ? 1 : 0;
1509         if (setsockopt(GetSocket(), SOL_SOCKET, SO_PASSCRED, (char *)&optval, sizeof(optval)) == -1)
1510         {
1511                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PASSCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1512                 return false;
1513         }
1514         return true;
1515 }
1516 #endif
1517
1518
1519 #ifdef SO_PEERCRED
1520 bool Socket::SoPeercred(struct ucred& ucr)
1521 {
1522         if (setsockopt(GetSocket(), SOL_SOCKET, SO_PEERCRED, (char *)&ucr, sizeof(ucr)) == -1)
1523         {
1524                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PEERCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1525                 return false;
1526         }
1527         return true;
1528 }
1529 #endif
1530
1531
1532 #ifdef SO_PRIORITY
1533 bool Socket::SetSoPriority(int x)
1534 {
1535         if (setsockopt(GetSocket(), SOL_SOCKET, SO_PRIORITY, (char *)&x, sizeof(x)) == -1)
1536         {
1537                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PRIORITY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1538                 return false;
1539         }
1540         return true;
1541 }
1542 #endif
1543
1544
1545 bool Socket::SetSoRcvlowat(int x)
1546 {
1547 #ifdef SO_RCVLOWAT
1548         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVLOWAT, (char *)&x, sizeof(x)) == -1)
1549         {
1550                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1551                 return false;
1552         }
1553         return true;
1554 #else
1555         Handler().LogError(this, "socket option not available", 0, "SO_RCVLOWAT", LOG_LEVEL_INFO);
1556         return false;
1557 #endif
1558 }
1559
1560
1561 bool Socket::SetSoSndlowat(int x)
1562 {
1563 #ifdef SO_SNDLOWAT
1564         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDLOWAT, (char *)&x, sizeof(x)) == -1)
1565         {
1566                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1567                 return false;
1568         }
1569         return true;
1570 #else
1571         Handler().LogError(this, "socket option not available", 0, "SO_SNDLOWAT", LOG_LEVEL_INFO);
1572         return false;
1573 #endif
1574 }
1575
1576
1577 bool Socket::SetSoRcvtimeo(struct timeval& tv)
1578 {
1579 #ifdef SO_RCVTIMEO
1580         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) == -1)
1581         {
1582                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1583                 return false;
1584         }
1585         return true;
1586 #else
1587         Handler().LogError(this, "socket option not available", 0, "SO_RCVTIMEO", LOG_LEVEL_INFO);
1588         return false;
1589 #endif
1590 }
1591
1592
1593 bool Socket::SetSoSndtimeo(struct timeval& tv)
1594 {
1595 #ifdef SO_SNDTIMEO
1596         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)) == -1)
1597         {
1598                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1599                 return false;
1600         }
1601         return true;
1602 #else
1603         Handler().LogError(this, "socket option not available", 0, "SO_SNDTIMEO", LOG_LEVEL_INFO);
1604         return false;
1605 #endif
1606 }
1607
1608
1609 bool Socket::SetSoRcvbuf(int x)
1610 {
1611 #ifdef SO_RCVBUF
1612         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&x, sizeof(x)) == -1)
1613         {
1614                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1615                 return false;
1616         }
1617         return true;
1618 #else
1619         Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
1620         return false;
1621 #endif
1622 }
1623
1624
1625 int Socket::SoRcvbuf()
1626 {
1627         int value = 0;
1628 #ifdef SO_RCVBUF
1629         socklen_t len = sizeof(value);
1630         if (getsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&value, &len) == -1)
1631         {
1632                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1633         }
1634 #else
1635         Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
1636 #endif
1637         return value ? true : false;
1638 }
1639
1640
1641 #ifdef SO_RCVBUFFORCE
1642 bool Socket::SetSoRcvbufforce(int x)
1643 {
1644         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUFFORCE, (char *)&x, sizeof(x)) == -1)
1645         {
1646                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1647                 return false;
1648         }
1649         return true;
1650 }
1651 #endif
1652
1653
1654 bool Socket::SetSoSndbuf(int x)
1655 {
1656 #ifdef SO_SNDBUF
1657         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&x, sizeof(x)) == -1)
1658         {
1659                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1660                 return false;
1661         }
1662         return true;
1663 #else
1664         Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
1665         return false;
1666 #endif
1667 }
1668
1669
1670 int Socket::SoSndbuf()
1671 {
1672         int value = 0;
1673 #ifdef SO_SNDBUF
1674         socklen_t len = sizeof(value);
1675         if (getsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&value, &len) == -1)
1676         {
1677                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1678         }
1679 #else
1680         Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
1681 #endif
1682         return value ? true : false;
1683 }
1684
1685
1686 #ifdef SO_SNDBUFFORCE
1687 bool Socket::SetSoSndbufforce(int x)
1688 {
1689         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUFFORCE, (char *)&x, sizeof(x)) == -1)
1690         {
1691                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1692                 return false;
1693         }
1694         return true;
1695 }
1696 #endif
1697
1698
1699 #ifdef SO_TIMESTAMP
1700 bool Socket::SetSoTimestamp(bool x)
1701 {
1702         int optval = x ? 1 : 0;
1703         if (setsockopt(GetSocket(), SOL_SOCKET, SO_TIMESTAMP, (char *)&optval, sizeof(optval)) == -1)
1704         {
1705                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_TIMESTAMP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1706                 return false;
1707         }
1708         return true;
1709 }
1710 #endif
1711
1712
1713 int Socket::SoType()
1714 {
1715         int value = 0;
1716 #ifdef SO_TYPE
1717         socklen_t len = sizeof(value);
1718         if (getsockopt(GetSocket(), SOL_SOCKET, SO_TYPE, (char *)&value, &len) == -1)
1719         {
1720                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_TYPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
1721         }
1722 #else
1723         Handler().LogError(this, "socket option not available", 0, "SO_TYPE", LOG_LEVEL_INFO);
1724 #endif
1725         return value ? true : false;
1726 }
1727
1728
1729 #ifdef ENABLE_TRIGGERS
1730 void Socket::Subscribe(int id)
1731 {
1732         Handler().Subscribe(id, this);
1733 }
1734
1735
1736 void Socket::Unsubscribe(int id)
1737 {
1738         Handler().Unsubscribe(id, this);
1739 }
1740
1741
1742 void Socket::OnTrigger(int, const TriggerData&)
1743 {
1744 }
1745
1746
1747 void Socket::OnCancelled(int)
1748 {
1749 }
1750 #endif
1751
1752
1753 void Socket::SetTimeout(time_t secs)
1754 {
1755         if (!secs)
1756         {
1757                 Handler().AddList(m_socket, LIST_TIMEOUT, false);
1758                 return;
1759         }
1760         Handler().AddList(m_socket, LIST_TIMEOUT, true);
1761         m_timeout_start = time(NULL);
1762         m_timeout_limit = secs;
1763 }
1764
1765
1766 void Socket::OnTimeout()
1767 {
1768 }
1769
1770
1771 void Socket::OnConnectTimeout()
1772 {
1773 }
1774
1775
1776 bool Socket::Timeout(time_t tnow)
1777 {
1778         if (tnow - m_timeout_start > m_timeout_limit)
1779                 return true;
1780         return false;
1781 }
1782
1783
1784 #ifdef SOCKETS_NAMESPACE
1785 }
1786 #endif