Logo
~Sockets~
~Examples~
~Contact~


Socket.cpp

Go to the documentation of this file.
00001 
00005 /*
00006 Copyright (C) 2004-2007  Anders Hedstrom
00007 
00008 This library is made available under the terms of the GNU GPL.
00009 
00010 If you would like to use this library in a closed-source application,
00011 a separate license agreement is available. For information about
00012 the closed-source license agreement for the C++ sockets library,
00013 please visit http://www.alhem.net/Sockets/license.html and/or
00014 email license@alhem.net.
00015 
00016 This program is free software; you can redistribute it and/or
00017 modify it under the terms of the GNU General Public License
00018 as published by the Free Software Foundation; either version 2
00019 of the License, or (at your option) any later version.
00020 
00021 This program is distributed in the hope that it will be useful,
00022 but WITHOUT ANY WARRANTY; without even the implied warranty of
00023 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00024 GNU General Public License for more details.
00025 
00026 You should have received a copy of the GNU General Public License
00027 along with this program; if not, write to the Free Software
00028 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00029 */
00030 #include "Socket.h"
00031 #ifdef _WIN32
00032 #pragma warning(disable:4786)
00033 #include <stdlib.h>
00034 #else
00035 #include <errno.h>
00036 #include <netdb.h>
00037 #endif
00038 #include <ctype.h>
00039 #include <fcntl.h>
00040 
00041 #include "ISocketHandler.h"
00042 #include "Utility.h"
00043 
00044 #include "SocketAddress.h"
00045 #include "SocketHandler.h"
00046 
00047 #ifdef _DEBUG
00048 #define DEB(x) x; fflush(stderr);
00049 #else
00050 #define DEB(x)
00051 #endif
00052 
00053 #ifdef SOCKETS_NAMESPACE
00054 namespace SOCKETS_NAMESPACE {
00055 #endif
00056 
00057 
00058 // statics
00059 #ifdef _WIN32
00060 WSAInitializer Socket::m_winsock_init;
00061 #endif
00062 
00063 
00064 Socket::Socket(ISocketHandler& h)
00065 //:m_flags(0)
00066 :m_handler(h)
00067 ,m_socket( INVALID_SOCKET )
00068 ,m_bDel(false)
00069 ,m_bClose(false)
00070 ,m_tCreate(time(NULL))
00071 ,m_parent(NULL)
00072 ,m_b_disable_read(false)
00073 ,m_connected(false)
00074 ,m_b_erased_by_handler(false)
00075 ,m_tClose(0)
00076 ,m_client_remote_address(NULL)
00077 ,m_remote_address(NULL)
00078 ,m_traffic_monitor(NULL)
00079 #ifdef HAVE_OPENSSL
00080 ,m_b_enable_ssl(false)
00081 ,m_b_ssl(false)
00082 ,m_b_ssl_server(false)
00083 #endif
00084 #ifdef ENABLE_IPV6
00085 ,m_ipv6(false)
00086 #endif
00087 #ifdef ENABLE_POOL
00088 ,m_socket_type(0)
00089 ,m_bClient(false)
00090 ,m_bRetain(false)
00091 ,m_bLost(false)
00092 #endif
00093 #ifdef ENABLE_SOCKS4
00094 ,m_bSocks4(false)
00095 ,m_socks4_host(h.GetSocks4Host())
00096 ,m_socks4_port(h.GetSocks4Port())
00097 ,m_socks4_userid(h.GetSocks4Userid())
00098 #endif
00099 #ifdef ENABLE_DETACH
00100 ,m_detach(false)
00101 ,m_detached(false)
00102 ,m_pThread(NULL)
00103 ,m_slave_handler(NULL)
00104 #endif
00105 {
00106 }
00107 
00108 
00109 Socket::~Socket()
00110 {
00111         Handler().Remove(this);
00112         if (m_socket != INVALID_SOCKET
00113 #ifdef ENABLE_POOL
00114                  && !m_bRetain
00115 #endif
00116                 )
00117         {
00118                 Close();
00119         }
00120 }
00121 
00122 
00123 void Socket::Init()
00124 {
00125 }
00126 
00127 
00128 void Socket::OnRead()
00129 {
00130 }
00131 
00132 
00133 void Socket::OnWrite()
00134 {
00135 }
00136 
00137 
00138 void Socket::OnException()
00139 {
00140         // %! exception doesn't always mean something bad happened, this code should be reworked
00141         // errno valid here?
00142         int err = SoError();
00143         Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
00144         SetCloseAndDelete();
00145 }
00146 
00147 
00148 void Socket::OnDelete()
00149 {
00150 }
00151 
00152 
00153 void Socket::OnConnect()
00154 {
00155 }
00156 
00157 
00158 void Socket::OnAccept()
00159 {
00160 }
00161 
00162 
00163 int Socket::Close()
00164 {
00165         if (m_socket == INVALID_SOCKET) // this could happen
00166         {
00167                 Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
00168                 return 0;
00169         }
00170         int n;
00171         if ((n = closesocket(m_socket)) == -1)
00172         {
00173                 // failed...
00174                 Handler().LogError(this, "close", Errno, StrError(Errno), LOG_LEVEL_ERROR);
00175         }
00176         Handler().Set(m_socket, false, false, false); // remove from fd_set's
00177         Handler().AddList(m_socket, LIST_CALLONCONNECT, false);
00178 #ifdef ENABLE_DETACH
00179         Handler().AddList(m_socket, LIST_DETACH, false);
00180 #endif
00181         Handler().AddList(m_socket, LIST_TIMEOUT, false);
00182         Handler().AddList(m_socket, LIST_RETRY, false);
00183         Handler().AddList(m_socket, LIST_CLOSE, false);
00184         m_socket = INVALID_SOCKET;
00185         return n;
00186 }
00187 
00188 
00189 SOCKET Socket::CreateSocket(int af,int type, const std::string& protocol)
00190 {
00191         struct protoent *p = NULL;
00192         SOCKET s;
00193 
00194 #ifdef ENABLE_POOL
00195         m_socket_type = type;
00196         m_socket_protocol = protocol;
00197 #endif
00198         if (protocol.size())
00199         {
00200                 p = getprotobyname( protocol.c_str() );
00201                 if (!p)
00202                 {
00203                         Handler().LogError(this, "getprotobyname", Errno, StrError(Errno), LOG_LEVEL_FATAL);
00204                         SetCloseAndDelete();
00205                         return INVALID_SOCKET;
00206                 }
00207         }
00208         int protno = p ? p -> p_proto : 0;
00209 
00210         s = socket(af, type, protno);
00211         if (s == INVALID_SOCKET)
00212         {
00213                 Handler().LogError(this, "socket", Errno, StrError(Errno), LOG_LEVEL_FATAL);
00214                 SetCloseAndDelete();
00215                 return INVALID_SOCKET;
00216         }
00217         Attach(s);
00218         OnOptions(af, type, protno, s);
00219         Attach(INVALID_SOCKET);
00220         return s;
00221 }
00222 
00223 
00224 void Socket::Attach(SOCKET s)
00225 {
00226         m_socket = s;
00227 }
00228 
00229 
00230 SOCKET Socket::GetSocket()
00231 {
00232         return m_socket;
00233 }
00234 
00235 
00236 void Socket::SetDeleteByHandler(bool x)
00237 {
00238         m_bDel = x;
00239 }
00240 
00241 
00242 bool Socket::DeleteByHandler()
00243 {
00244         return m_bDel;
00245 }
00246 
00247 
00248 void Socket::SetCloseAndDelete(bool x)
00249 {
00250         if (x != m_bClose)
00251         {
00252                 Handler().AddList(m_socket, LIST_CLOSE, x);
00253                 m_bClose = x;
00254                 if (x)
00255                 {
00256                         m_tClose = time(NULL);
00257                 }
00258         }
00259 }
00260 
00261 
00262 bool Socket::CloseAndDelete()
00263 {
00264         return m_bClose;
00265 }
00266 
00267 
00268 void Socket::SetRemoteAddress(SocketAddress& ad) //struct sockaddr* sa, socklen_t l)
00269 {
00270         m_remote_address = ad.GetCopy();
00271 }
00272 
00273 
00274 std::auto_ptr<SocketAddress> Socket::GetRemoteSocketAddress()
00275 {
00276         return std::auto_ptr<SocketAddress>(m_remote_address -> GetCopy());
00277 }
00278 
00279 
00280 ISocketHandler& Socket::Handler() const
00281 {
00282 #ifdef ENABLE_DETACH
00283         if (IsDetached())
00284                 return *m_slave_handler;
00285 #endif
00286         return m_handler;
00287 }
00288 
00289 
00290 ISocketHandler& Socket::MasterHandler() const
00291 {
00292         return m_handler;
00293 }
00294 
00295 
00296 ipaddr_t Socket::GetRemoteIP4()
00297 {
00298         ipaddr_t l = 0;
00299 #ifdef ENABLE_IPV6
00300         if (m_ipv6)
00301         {
00302                 Handler().LogError(this, "GetRemoteIP4", 0, "get ipv4 address for ipv6 socket", LOG_LEVEL_WARNING);
00303         }
00304 #endif
00305         if (m_remote_address.get() != NULL)
00306         {
00307                 struct sockaddr *p = *m_remote_address;
00308                 struct sockaddr_in *sa = (struct sockaddr_in *)p;
00309                 memcpy(&l, &sa -> sin_addr, sizeof(struct in_addr));
00310         }
00311         return l;
00312 }
00313 
00314 
00315 #ifdef ENABLE_IPV6
00316 #ifdef IPPROTO_IPV6
00317 struct in6_addr Socket::GetRemoteIP6()
00318 {
00319         if (!m_ipv6)
00320         {
00321                 Handler().LogError(this, "GetRemoteIP6", 0, "get ipv6 address for ipv4 socket", LOG_LEVEL_WARNING);
00322         }
00323         struct sockaddr_in6 fail;
00324         if (m_remote_address.get() != NULL)
00325         {
00326                 struct sockaddr *p = *m_remote_address;
00327                 memcpy(&fail, p, sizeof(struct sockaddr_in6));
00328         }
00329         else
00330         {
00331                 memset(&fail, 0, sizeof(struct sockaddr_in6));
00332         }
00333         return fail.sin6_addr;
00334 }
00335 #endif
00336 #endif
00337 
00338 
00339 port_t Socket::GetRemotePort()
00340 {
00341         if (!m_remote_address.get())
00342         {
00343                 return 0;
00344         }
00345         return m_remote_address -> GetPort();
00346 }
00347 
00348 
00349 std::string Socket::GetRemoteAddress()
00350 {
00351         if (!m_remote_address.get())
00352         {
00353                 return "";
00354         }
00355         return m_remote_address -> Convert(false);
00356 }
00357 
00358 
00359 std::string Socket::GetRemoteHostname()
00360 {
00361         if (!m_remote_address.get())
00362         {
00363                 return "";
00364         }
00365         return m_remote_address -> Reverse();
00366 }
00367 
00368 
00369 bool Socket::SetNonblocking(bool bNb)
00370 {
00371 #ifdef _WIN32
00372         unsigned long l = bNb ? 1 : 0;
00373         int n = ioctlsocket(m_socket, FIONBIO, &l);
00374         if (n != 0)
00375         {
00376                 Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
00377                 return false;
00378         }
00379         return true;
00380 #else
00381         if (bNb)
00382         {
00383                 if (fcntl(m_socket, F_SETFL, O_NONBLOCK) == -1)
00384                 {
00385                         Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
00386                         return false;
00387                 }
00388         }
00389         else
00390         {
00391                 if (fcntl(m_socket, F_SETFL, 0) == -1)
00392                 {
00393                         Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
00394                         return false;
00395                 }
00396         }
00397         return true;
00398 #endif
00399 }
00400 
00401 
00402 bool Socket::SetNonblocking(bool bNb, SOCKET s)
00403 {
00404 #ifdef _WIN32
00405         unsigned long l = bNb ? 1 : 0;
00406         int n = ioctlsocket(s, FIONBIO, &l);
00407         if (n != 0)
00408         {
00409                 Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
00410                 return false;
00411         }
00412         return true;
00413 #else
00414         if (bNb)
00415         {
00416                 if (fcntl(s, F_SETFL, O_NONBLOCK) == -1)
00417                 {
00418                         Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
00419                         return false;
00420                 }
00421         }
00422         else
00423         {
00424                 if (fcntl(s, F_SETFL, 0) == -1)
00425                 {
00426                         Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
00427                         return false;
00428                 }
00429         }
00430         return true;
00431 #endif
00432 }
00433 
00434 
00435 void Socket::Set(bool bRead, bool bWrite, bool bException)
00436 {
00437         Handler().Set(m_socket, bRead, bWrite, bException);
00438 }
00439 
00440 
00441 bool Socket::Ready()
00442 {
00443         if (m_socket != INVALID_SOCKET && !CloseAndDelete())
00444                 return true;
00445         return false;
00446 }
00447 
00448 
00449 void Socket::OnLine(const std::string& )
00450 {
00451 }
00452 
00453 
00454 void Socket::OnConnectFailed()
00455 {
00456 }
00457 
00458 
00459 Socket *Socket::GetParent()
00460 {
00461         return m_parent;
00462 }
00463 
00464 
00465 void Socket::SetParent(Socket *x)
00466 {
00467         m_parent = x;
00468 }
00469 
00470 
00471 port_t Socket::GetPort()
00472 {
00473         Handler().LogError(this, "GetPort", 0, "GetPort only implemented for ListenSocket", LOG_LEVEL_WARNING);
00474         return 0;
00475 }
00476 
00477 
00478 bool Socket::OnConnectRetry()
00479 {
00480         return true;
00481 }
00482 
00483 
00484 #ifdef ENABLE_RECONNECT
00485 void Socket::OnReconnect()
00486 {
00487 }
00488 #endif
00489 
00490 
00491 time_t Socket::Uptime()
00492 {
00493         return time(NULL) - m_tCreate;
00494 }
00495 
00496 
00497 #ifdef ENABLE_IPV6
00498 void Socket::SetIpv6(bool x)
00499 {
00500         m_ipv6 = x;
00501 }
00502 
00503 
00504 bool Socket::IsIpv6()
00505 {
00506         return m_ipv6;
00507 }
00508 #endif
00509 
00510 
00511 void Socket::DisableRead(bool x)
00512 {
00513         m_b_disable_read = x;
00514 }
00515 
00516 
00517 bool Socket::IsDisableRead()
00518 {
00519         return m_b_disable_read;
00520 }
00521 
00522 
00523 void Socket::SendBuf(const char *,size_t,int)
00524 {
00525 }
00526 
00527 
00528 void Socket::Send(const std::string&,int)
00529 {
00530 }
00531 
00532 
00533 void Socket::SetConnected(bool x)
00534 {
00535         m_connected = x;
00536 }
00537 
00538 
00539 bool Socket::IsConnected()
00540 {
00541         return m_connected;
00542 }
00543 
00544 
00545 #ifdef ENABLE_RECONNECT
00546 void Socket::OnDisconnect()
00547 {
00548 }
00549 #endif
00550 
00551 
00552 void Socket::SetErasedByHandler(bool x)
00553 {
00554         m_b_erased_by_handler = x;
00555 }
00556 
00557 
00558 bool Socket::ErasedByHandler()
00559 {
00560         return m_b_erased_by_handler;
00561 }
00562 
00563 
00564 time_t Socket::TimeSinceClose()
00565 {
00566         return time(NULL) - m_tClose;
00567 }
00568 
00569 
00570 void Socket::SetClientRemoteAddress(SocketAddress& ad)
00571 {
00572         if (!ad.IsValid())
00573         {
00574                 Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);
00575         }
00576         m_client_remote_address = ad.GetCopy();
00577 }
00578 
00579 
00580 std::auto_ptr<SocketAddress> Socket::GetClientRemoteAddress()
00581 {
00582         if (!m_client_remote_address.get())
00583         {
00584                 Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);
00585         }
00586         return std::auto_ptr<SocketAddress>(m_client_remote_address -> GetCopy());
00587 }
00588 
00589 
00590 uint64_t Socket::GetBytesSent(bool)
00591 {
00592         return 0;
00593 }
00594 
00595 
00596 uint64_t Socket::GetBytesReceived(bool)
00597 {
00598         return 0;
00599 }
00600 
00601 
00602 #ifdef HAVE_OPENSSL
00603 void Socket::OnSSLConnect()
00604 {
00605 }
00606 
00607 
00608 void Socket::OnSSLAccept()
00609 {
00610 }
00611 
00612 
00613 bool Socket::SSLNegotiate()
00614 {
00615         return false;
00616 }
00617 
00618 
00619 bool Socket::IsSSL()
00620 {
00621         return m_b_enable_ssl;
00622 }
00623 
00624 
00625 void Socket::EnableSSL(bool x)
00626 {
00627         m_b_enable_ssl = x;
00628 }
00629 
00630 
00631 bool Socket::IsSSLNegotiate()
00632 {
00633         return m_b_ssl;
00634 }
00635 
00636 
00637 void Socket::SetSSLNegotiate(bool x)
00638 {
00639         m_b_ssl = x;
00640 }
00641 
00642 
00643 bool Socket::IsSSLServer()
00644 {
00645         return m_b_ssl_server;
00646 }
00647 
00648 
00649 void Socket::SetSSLServer(bool x)
00650 {
00651         m_b_ssl_server = x;
00652 }
00653 
00654 
00655 void Socket::OnSSLConnectFailed()
00656 {
00657 }
00658 
00659 
00660 void Socket::OnSSLAcceptFailed()
00661 {
00662 }
00663 #endif // HAVE_OPENSSL
00664 
00665 
00666 #ifdef ENABLE_POOL
00667 void Socket::CopyConnection(Socket *sock)
00668 {
00669         Attach( sock -> GetSocket() );
00670 #ifdef ENABLE_IPV6
00671         SetIpv6( sock -> IsIpv6() );
00672 #endif
00673         SetSocketType( sock -> GetSocketType() );
00674         SetSocketProtocol( sock -> GetSocketProtocol() );
00675 
00676         SetClientRemoteAddress( *sock -> GetClientRemoteAddress() );
00677         SetRemoteAddress( *sock -> GetRemoteSocketAddress() );
00678 }
00679 
00680 
00681 void Socket::SetIsClient()
00682 {
00683         m_bClient = true;
00684 }
00685 
00686 
00687 void Socket::SetSocketType(int x)
00688 {
00689         m_socket_type = x;
00690 }
00691 
00692 
00693 int Socket::GetSocketType()
00694 {
00695         return m_socket_type;
00696 }
00697 
00698 
00699 void Socket::SetSocketProtocol(const std::string& x)
00700 {
00701         m_socket_protocol = x;
00702 }
00703 
00704 
00705 const std::string& Socket::GetSocketProtocol()
00706 {
00707         return m_socket_protocol;
00708 }
00709 
00710 
00711 void Socket::SetRetain()
00712 {
00713         if (m_bClient) m_bRetain = true;
00714 }
00715 
00716 
00717 bool Socket::Retain()
00718 {
00719         return m_bRetain;
00720 }
00721 
00722 
00723 void Socket::SetLost()
00724 {
00725         m_bLost = true;
00726 }
00727 
00728 
00729 bool Socket::Lost()
00730 {
00731         return m_bLost;
00732 }
00733 #endif // ENABLE_POOL
00734 
00735 
00736 #ifdef ENABLE_SOCKS4
00737 void Socket::OnSocks4Connect()
00738 {
00739         Handler().LogError(this, "OnSocks4Connect", 0, "Use with TcpSocket only");
00740 }
00741 
00742 
00743 void Socket::OnSocks4ConnectFailed()
00744 {
00745         Handler().LogError(this, "OnSocks4ConnectFailed", 0, "Use with TcpSocket only");
00746 }
00747 
00748 
00749 bool Socket::OnSocks4Read()
00750 {
00751         Handler().LogError(this, "OnSocks4Read", 0, "Use with TcpSocket only");
00752         return true;
00753 }
00754 
00755 
00756 void Socket::SetSocks4Host(const std::string& host)
00757 {
00758         Utility::u2ip(host, m_socks4_host);
00759 }
00760 
00761 
00762 bool Socket::Socks4()
00763 {
00764         return m_bSocks4;
00765 }
00766 
00767 
00768 void Socket::SetSocks4(bool x)
00769 {
00770         m_bSocks4 = x;
00771 }
00772 
00773 
00774 void Socket::SetSocks4Host(ipaddr_t a)
00775 {
00776         m_socks4_host = a;
00777 }
00778 
00779 
00780 void Socket::SetSocks4Port(port_t p)
00781 {
00782         m_socks4_port = p;
00783 }
00784 
00785 
00786 void Socket::SetSocks4Userid(const std::string& x)
00787 {
00788         m_socks4_userid = x;
00789 }
00790 
00791 
00792 ipaddr_t Socket::GetSocks4Host()
00793 {
00794         return m_socks4_host;
00795 }
00796 
00797 
00798 port_t Socket::GetSocks4Port()
00799 {
00800         return m_socks4_port;
00801 }
00802 
00803 
00804 const std::string& Socket::GetSocks4Userid()
00805 {
00806         return m_socks4_userid;
00807 }
00808 #endif // ENABLE_SOCKS4
00809 
00810 
00811 #ifdef ENABLE_DETACH
00812 bool Socket::Detach()
00813 {
00814         if (!DeleteByHandler())
00815                 return false;
00816         if (m_pThread)
00817                 return false;
00818         if (m_detached)
00819                 return false;
00820         SetDetach();
00821         return true;
00822 }
00823 
00824 
00825 void Socket::DetachSocket()
00826 {
00827         SetDetached();
00828         m_pThread = new SocketThread(this);
00829         m_pThread -> SetRelease(true);
00830 }
00831 
00832 
00833 void Socket::OnDetached()
00834 {
00835 }
00836 
00837 
00838 void Socket::SetDetach(bool x)
00839 {
00840         Handler().AddList(m_socket, LIST_DETACH, x);
00841         m_detach = x;
00842 }
00843 
00844 
00845 bool Socket::IsDetach()
00846 {
00847         return m_detach;
00848 }
00849 
00850 
00851 void Socket::SetDetached(bool x)
00852 {
00853         m_detached = x;
00854 }
00855 
00856 
00857 const bool Socket::IsDetached() const
00858 {
00859         return m_detached;
00860 }
00861 
00862 
00863 void Socket::SetSlaveHandler(ISocketHandler *p)
00864 {
00865         m_slave_handler = p;
00866 }
00867 
00868 
00869 Socket::SocketThread::SocketThread(Socket *p)
00870 :Thread(false)
00871 ,m_socket(p)
00872 {
00873         // Creator will release
00874 }
00875 
00876 
00877 Socket::SocketThread::~SocketThread()
00878 {
00879         if (IsRunning())
00880         {
00881                 SetRelease(true);
00882                 SetRunning(false);
00883 #ifdef _WIN32
00884                 Sleep(1000);
00885 #else
00886                 sleep(1);
00887 #endif
00888         }
00889 }
00890 
00891 
00892 void Socket::SocketThread::Run()
00893 {
00894         SocketHandler h;
00895         h.SetSlave();
00896         h.Add(m_socket);
00897         m_socket -> SetSlaveHandler(&h);
00898         m_socket -> OnDetached();
00899         while (h.GetCount() && IsRunning())
00900         {
00901                 h.Select(0, 500000);
00902         }
00903         // m_socket now deleted oops
00904         // yeah oops m_socket delete its socket thread, that means this
00905         // so Socket will no longer delete its socket thread, instead we do this:
00906         SetDeleteOnExit();
00907 }
00908 #endif // ENABLE_DETACH
00909 
00910 
00911 #ifdef ENABLE_RESOLVER
00912 int Socket::Resolve(const std::string& host,port_t port)
00913 {
00914         return Handler().Resolve(this, host, port);
00915 }
00916 
00917 
00918 #ifdef ENABLE_IPV6
00919 int Socket::Resolve6(const std::string& host,port_t port)
00920 {
00921         return Handler().Resolve6(this, host, port);
00922 }
00923 #endif
00924 
00925 
00926 int Socket::Resolve(ipaddr_t a)
00927 {
00928         return Handler().Resolve(this, a);
00929 }
00930 
00931 
00932 #ifdef ENABLE_IPV6
00933 int Socket::Resolve(in6_addr& a)
00934 {
00935         return Handler().Resolve(this, a);
00936 }
00937 #endif
00938 
00939 
00940 void Socket::OnResolved(int,ipaddr_t,port_t)
00941 {
00942 }
00943 
00944 
00945 #ifdef ENABLE_IPV6
00946 void Socket::OnResolved(int,in6_addr&,port_t)
00947 {
00948 }
00949 #endif
00950 
00951 
00952 void Socket::OnReverseResolved(int,const std::string&)
00953 {
00954 }
00955 
00956 
00957 void Socket::OnResolveFailed(int)
00958 {
00959 }
00960 #endif // ENABLE_RESOLVER
00961 
00962 
00963 /* IP options */
00964 
00965 
00966 bool Socket::SetIpOptions(const void *p, socklen_t len)
00967 {
00968 #ifdef IP_OPTIONS
00969         if (setsockopt(GetSocket(), IPPROTO_IP, IP_OPTIONS, (char *)p, len) == -1)
00970         {
00971                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_OPTIONS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
00972                 return false;
00973         }
00974         return true;
00975 #else
00976         Handler().LogError(this, "ip option not available", 0, "IP_OPTIONS", LOG_LEVEL_INFO);
00977         return false;
00978 #endif
00979 }
00980 
00981 
00982 #ifdef IP_PKTINFO
00983 bool Socket::SetIpPktinfo(bool x)
00984 {
00985         int optval = x ? 1 : 0;
00986         if (setsockopt(GetSocket(), IPPROTO_IP, IP_PKTINFO, (char *)&optval, sizeof(optval)) == -1)
00987         {
00988                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_PKTINFO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
00989                 return false;
00990         }
00991         return true;
00992 }
00993 #endif
00994 
00995 
00996 #ifdef IP_RECVTOS
00997 bool Socket::SetIpRecvTOS(bool x)
00998 {
00999         int optval = x ? 1 : 0;
01000         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTOS, (char *)&optval, sizeof(optval)) == -1)
01001         {
01002                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01003                 return false;
01004         }
01005         return true;
01006 }
01007 #endif
01008 
01009 
01010 #ifdef IP_RECVTTL
01011 bool Socket::SetIpRecvTTL(bool x)
01012 {
01013         int optval = x ? 1 : 0;
01014         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTTL, (char *)&optval, sizeof(optval)) == -1)
01015         {
01016                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01017                 return false;
01018         }
01019         return true;
01020 }
01021 #endif
01022 
01023 
01024 #ifdef IP_RECVOPTS
01025 bool Socket::SetIpRecvopts(bool x)
01026 {
01027         int optval = x ? 1 : 0;
01028         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVOPTS, (char *)&optval, sizeof(optval)) == -1)
01029         {
01030                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01031                 return false;
01032         }
01033         return true;
01034 }
01035 #endif
01036 
01037 
01038 #ifdef IP_RETOPTS
01039 bool Socket::SetIpRetopts(bool x)
01040 {
01041         int optval = x ? 1 : 0;
01042         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RETOPTS, (char *)&optval, sizeof(optval)) == -1)
01043         {
01044                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RETOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01045                 return false;
01046         }
01047         return true;
01048 }
01049 #endif
01050 
01051 
01052 bool Socket::SetIpTOS(unsigned char tos)
01053 {
01054 #ifdef IP_TOS
01055         if (setsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(tos)) == -1)
01056         {
01057                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01058                 return false;
01059         }
01060         return true;
01061 #else
01062         Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
01063         return false;
01064 #endif
01065 }
01066 
01067 
01068 unsigned char Socket::IpTOS()
01069 {
01070         unsigned char tos = 0;
01071 #ifdef IP_TOS
01072         socklen_t len = sizeof(tos);
01073         if (getsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, &len) == -1)
01074         {
01075                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01076         }
01077 #else
01078         Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
01079 #endif
01080         return tos;
01081 }
01082 
01083 
01084 bool Socket::SetIpTTL(int ttl)
01085 {
01086 #ifdef IP_TTL
01087         if (setsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl)) == -1)
01088         {
01089                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01090                 return false;
01091         }
01092         return true;
01093 #else
01094         Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
01095         return false;
01096 #endif
01097 }
01098 
01099 
01100 int Socket::IpTTL()
01101 {
01102         int ttl = 0;
01103 #ifdef IP_TTL
01104         socklen_t len = sizeof(ttl);
01105         if (getsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, &len) == -1)
01106         {
01107                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01108         }
01109 #else
01110         Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
01111 #endif
01112         return ttl;
01113 }
01114 
01115 
01116 bool Socket::SetIpHdrincl(bool x)
01117 {
01118 #ifdef IP_HDRINCL
01119         int optval = x ? 1 : 0;
01120         if (setsockopt(GetSocket(), IPPROTO_IP, IP_HDRINCL, (char *)&optval, sizeof(optval)) == -1)
01121         {
01122                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_HDRINCL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01123                 return false;
01124         }
01125         return true;
01126 #else
01127         Handler().LogError(this, "ip option not available", 0, "IP_HDRINCL", LOG_LEVEL_INFO);
01128         return false;
01129 #endif
01130 }
01131 
01132 
01133 #ifdef IP_RECVERR
01134 bool Socket::SetIpRecverr(bool x)
01135 {
01136         int optval = x ? 1 : 0;
01137         if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVERR, (char *)&optval, sizeof(optval)) == -1)
01138         {
01139                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVERR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01140                 return false;
01141         }
01142         return true;
01143 }
01144 #endif
01145 
01146 
01147 #ifdef IP_MTU_DISCOVER
01148 bool Socket::SetIpMtudiscover(bool x)
01149 {
01150         int optval = x ? 1 : 0;
01151         if (setsockopt(GetSocket(), IPPROTO_IP, IP_MTU_DISCOVER, (char *)&optval, sizeof(optval)) == -1)
01152         {
01153                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MTU_DISCOVER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01154                 return false;
01155         }
01156         return true;
01157 }
01158 #endif
01159 
01160 
01161 #ifdef IP_MTU
01162 int Socket::IpMtu()
01163 {
01164         int mtu = 0;
01165         socklen_t len = sizeof(mtu);
01166         if (getsockopt(GetSocket(), IPPROTO_IP, IP_MTU, (char *)&mtu, &len) == -1)
01167         {
01168                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MTU)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01169         }
01170         return mtu;
01171 }
01172 #endif
01173 
01174 
01175 #ifdef IP_ROUTER_ALERT
01176 bool Socket::SetIpRouterAlert(bool x)
01177 {
01178         int optval = x ? 1 : 0;
01179         if (setsockopt(GetSocket(), IPPROTO_IP, IP_ROUTER_ALERT, (char *)&optval, sizeof(optval)) == -1)
01180         {
01181                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ROUTER_ALERT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01182                 return false;
01183         }
01184         return true;
01185 }
01186 #endif
01187 
01188 
01189 bool Socket::SetIpMulticastTTL(int ttl)
01190 {
01191 #ifdef IP_MULTICAST_TTL
01192         if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(ttl)) == -1)
01193         {
01194                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01195                 return false;
01196         }
01197         return true;
01198 #else
01199         Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
01200         return false;
01201 #endif
01202 }
01203 
01204 
01205 int Socket::IpMulticastTTL()
01206 {
01207         int ttl = 0;
01208 #ifdef IP_MULTICAST_TTL
01209         socklen_t len = sizeof(ttl);
01210         if (getsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, &len) == -1)
01211         {
01212                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01213         }
01214 #else
01215         Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
01216 #endif
01217         return ttl;
01218 }
01219 
01220 
01221 bool Socket::SetMulticastLoop(bool x)
01222 {
01223 #ifdef IP_MULTICAST_LOOP
01224         int optval = x ? 1 : 0;
01225         if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&optval, sizeof(optval)) == -1)
01226         {
01227                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_LOOP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01228                 return false;
01229         }
01230         return true;
01231 #else
01232         Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_LOOP", LOG_LEVEL_INFO);
01233         return false;
01234 #endif
01235 }
01236 
01237 
01238 #ifdef LINUX
01239 bool Socket::IpAddMembership(struct ip_mreqn& ref)
01240 {
01241 #ifdef IP_ADD_MEMBERSHIP
01242         if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
01243         {
01244                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01245                 return false;
01246         }
01247         return true;
01248 #else
01249         Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
01250         return false;
01251 #endif
01252 }
01253 #endif
01254 
01255 
01256 bool Socket::IpAddMembership(struct ip_mreq& ref)
01257 {
01258 #ifdef IP_ADD_MEMBERSHIP
01259         if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
01260         {
01261                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01262                 return false;
01263         }
01264         return true;
01265 #else
01266         Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
01267         return false;
01268 #endif
01269 }
01270 
01271 
01272 #ifdef LINUX
01273 bool Socket::IpDropMembership(struct ip_mreqn& ref)
01274 {
01275 #ifdef IP_DROP_MEMBERSHIP
01276         if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
01277         {
01278                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01279                 return false;
01280         }
01281         return true;
01282 #else
01283         Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
01284         return false;
01285 #endif
01286 }
01287 #endif
01288 
01289 
01290 bool Socket::IpDropMembership(struct ip_mreq& ref)
01291 {
01292 #ifdef IP_DROP_MEMBERSHIP
01293         if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
01294         {
01295                 Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01296                 return false;
01297         }
01298         return true;
01299 #else
01300         Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
01301         return false;
01302 #endif
01303 }
01304 
01305 
01306 /* SOCKET options */
01307 
01308 
01309 bool Socket::SetSoReuseaddr(bool x)
01310 {
01311 #ifdef SO_REUSEADDR
01312         int optval = x ? 1 : 0;
01313         if (setsockopt(GetSocket(), SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) == -1)
01314         {
01315                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_REUSEADDR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01316                 return false;
01317         }
01318         return true;
01319 #else
01320         Handler().LogError(this, "socket option not available", 0, "SO_REUSEADDR", LOG_LEVEL_INFO);
01321         return false;
01322 #endif
01323 }
01324 
01325 
01326 bool Socket::SetSoKeepalive(bool x)
01327 {
01328 #ifdef SO_KEEPALIVE
01329         int optval = x ? 1 : 0;
01330         if (setsockopt(GetSocket(), SOL_SOCKET, SO_KEEPALIVE, (char *)&optval, sizeof(optval)) == -1)
01331         {
01332                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_KEEPALIVE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01333                 return false;
01334         }
01335         return true;
01336 #else
01337         Handler().LogError(this, "socket option not available", 0, "SO_KEEPALIVE", LOG_LEVEL_INFO);
01338         return false;
01339 #endif
01340 }
01341 
01342 
01343 #ifdef SO_NOSIGPIPE
01344 bool Socket::SetSoNosigpipe(bool x)
01345 {
01346         int optval = x ? 1 : 0;
01347         if (setsockopt(GetSocket(), SOL_SOCKET, SO_NOSIGPIPE, (char *)&optval, sizeof(optval)) == -1)
01348         {
01349                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_NOSIGPIPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01350                 return false;
01351         }
01352         return true;
01353 }
01354 #endif
01355 
01356 
01357 bool Socket::SoAcceptconn()
01358 {
01359         int value = 0;
01360 #ifdef SO_ACCEPTCONN
01361         socklen_t len = sizeof(value);
01362         if (getsockopt(GetSocket(), SOL_SOCKET, SO_ACCEPTCONN, (char *)&value, &len) == -1)
01363         {
01364                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_ACCEPTCONN)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01365         }
01366 #else
01367         Handler().LogError(this, "socket option not available", 0, "SO_ACCEPTCONN", LOG_LEVEL_INFO);
01368 #endif
01369         return value ? true : false;
01370 }
01371 
01372 
01373 #ifdef SO_BSDCOMPAT
01374 bool Socket::SetSoBsdcompat(bool x)
01375 {
01376         int optval = x ? 1 : 0;
01377         if (setsockopt(GetSocket(), SOL_SOCKET, SO_BSDCOMPAT, (char *)&optval, sizeof(optval)) == -1)
01378         {
01379                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BSDCOMPAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01380                 return false;
01381         }
01382         return true;
01383 }
01384 #endif
01385 
01386 
01387 #ifdef SO_BINDTODEVICE
01388 bool Socket::SetSoBindtodevice(const std::string& intf)
01389 {
01390         if (setsockopt(GetSocket(), SOL_SOCKET, SO_BINDTODEVICE, (char *)intf.c_str(), intf.size()) == -1)
01391         {
01392                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BINDTODEVICE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01393                 return false;
01394         }
01395         return true;
01396 }
01397 #endif
01398 
01399 
01400 bool Socket::SetSoBroadcast(bool x)
01401 {
01402 #ifdef SO_BROADCAST
01403         int optval = x ? 1 : 0;
01404         if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) == -1)
01405         {
01406                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BROADCAST)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01407                 return false;
01408         }
01409         return true;
01410 #else
01411         Handler().LogError(this, "socket option not available", 0, "SO_BROADCAST", LOG_LEVEL_INFO);
01412         return false;
01413 #endif
01414 }
01415 
01416 
01417 bool Socket::SetSoDebug(bool x)
01418 {
01419 #ifdef SO_DEBUG
01420         int optval = x ? 1 : 0;
01421         if (setsockopt(GetSocket(), SOL_SOCKET, SO_DEBUG, (char *)&optval, sizeof(optval)) == -1)
01422         {
01423                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DEBUG)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01424                 return false;
01425         }
01426         return true;
01427 #else
01428         Handler().LogError(this, "socket option not available", 0, "SO_DEBUG", LOG_LEVEL_INFO);
01429         return false;
01430 #endif
01431 }
01432 
01433 
01434 int Socket::SoError()
01435 {
01436         int value = 0;
01437 #ifdef SO_ERROR
01438         socklen_t len = sizeof(value);
01439         if (getsockopt(GetSocket(), SOL_SOCKET, SO_ERROR, (char *)&value, &len) == -1)
01440         {
01441                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_ERROR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01442         }
01443 #else
01444         Handler().LogError(this, "socket option not available", 0, "SO_ERROR", LOG_LEVEL_INFO);
01445 #endif
01446         return value ? true : false;
01447 }
01448 
01449 
01450 bool Socket::SetSoDontroute(bool x)
01451 {
01452 #ifdef SO_DONTROUTE
01453         int optval = x ? 1 : 0;
01454         if (setsockopt(GetSocket(), SOL_SOCKET, SO_DONTROUTE, (char *)&optval, sizeof(optval)) == -1)
01455         {
01456                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DONTROUTE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01457                 return false;
01458         }
01459         return true;
01460 #else
01461         Handler().LogError(this, "socket option not available", 0, "SO_DONTROUTE", LOG_LEVEL_INFO);
01462         return false;
01463 #endif
01464 }
01465 
01466 
01467 bool Socket::SetSoLinger(int onoff, int linger)
01468 {
01469 #ifdef SO_LINGER
01470         struct linger stl;
01471         stl.l_onoff = onoff;
01472         stl.l_linger = linger;
01473         if (setsockopt(GetSocket(), SOL_SOCKET, SO_LINGER, (char *)&stl, sizeof(stl)) == -1)
01474         {
01475                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_LINGER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01476                 return false;
01477         }
01478         return true;
01479 #else
01480         Handler().LogError(this, "socket option not available", 0, "SO_LINGER", LOG_LEVEL_INFO);
01481         return false;
01482 #endif
01483 }
01484 
01485 
01486 bool Socket::SetSoOobinline(bool x)
01487 {
01488 #ifdef SO_OOBINLINE
01489         int optval = x ? 1 : 0;
01490         if (setsockopt(GetSocket(), SOL_SOCKET, SO_OOBINLINE, (char *)&optval, sizeof(optval)) == -1)
01491         {
01492                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_OOBINLINE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01493                 return false;
01494         }
01495         return true;
01496 #else
01497         Handler().LogError(this, "socket option not available", 0, "SO_OOBINLINE", LOG_LEVEL_INFO);
01498         return false;
01499 #endif
01500 }
01501 
01502 
01503 #ifdef SO_PASSCRED
01504 bool Socket::SetSoPasscred(bool x)
01505 {
01506         int optval = x ? 1 : 0;
01507         if (setsockopt(GetSocket(), SOL_SOCKET, SO_PASSCRED, (char *)&optval, sizeof(optval)) == -1)
01508         {
01509                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PASSCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01510                 return false;
01511         }
01512         return true;
01513 }
01514 #endif
01515 
01516 
01517 #ifdef SO_PEERCRED
01518 bool Socket::SoPeercred(struct ucred& ucr)
01519 {
01520         if (setsockopt(GetSocket(), SOL_SOCKET, SO_PEERCRED, (char *)&ucr, sizeof(ucr)) == -1)
01521         {
01522                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PEERCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01523                 return false;
01524         }
01525         return true;
01526 }
01527 #endif
01528 
01529 
01530 #ifdef SO_PRIORITY
01531 bool Socket::SetSoPriority(int x)
01532 {
01533         if (setsockopt(GetSocket(), SOL_SOCKET, SO_PRIORITY, (char *)&x, sizeof(x)) == -1)
01534         {
01535                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PRIORITY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01536                 return false;
01537         }
01538         return true;
01539 }
01540 #endif
01541 
01542 
01543 bool Socket::SetSoRcvlowat(int x)
01544 {
01545 #ifdef SO_RCVLOWAT
01546         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVLOWAT, (char *)&x, sizeof(x)) == -1)
01547         {
01548                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01549                 return false;
01550         }
01551         return true;
01552 #else
01553         Handler().LogError(this, "socket option not available", 0, "SO_RCVLOWAT", LOG_LEVEL_INFO);
01554         return false;
01555 #endif
01556 }
01557 
01558 
01559 bool Socket::SetSoSndlowat(int x)
01560 {
01561 #ifdef SO_SNDLOWAT
01562         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDLOWAT, (char *)&x, sizeof(x)) == -1)
01563         {
01564                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01565                 return false;
01566         }
01567         return true;
01568 #else
01569         Handler().LogError(this, "socket option not available", 0, "SO_SNDLOWAT", LOG_LEVEL_INFO);
01570         return false;
01571 #endif
01572 }
01573 
01574 
01575 bool Socket::SetSoRcvtimeo(struct timeval& tv)
01576 {
01577 #ifdef SO_RCVTIMEO
01578         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) == -1)
01579         {
01580                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01581                 return false;
01582         }
01583         return true;
01584 #else
01585         Handler().LogError(this, "socket option not available", 0, "SO_RCVTIMEO", LOG_LEVEL_INFO);
01586         return false;
01587 #endif
01588 }
01589 
01590 
01591 bool Socket::SetSoSndtimeo(struct timeval& tv)
01592 {
01593 #ifdef SO_SNDTIMEO
01594         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)) == -1)
01595         {
01596                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01597                 return false;
01598         }
01599         return true;
01600 #else
01601         Handler().LogError(this, "socket option not available", 0, "SO_SNDTIMEO", LOG_LEVEL_INFO);
01602         return false;
01603 #endif
01604 }
01605 
01606 
01607 bool Socket::SetSoRcvbuf(int x)
01608 {
01609 #ifdef SO_RCVBUF
01610         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&x, sizeof(x)) == -1)
01611         {
01612                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01613                 return false;
01614         }
01615         return true;
01616 #else
01617         Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
01618         return false;
01619 #endif
01620 }
01621 
01622 
01623 int Socket::SoRcvbuf()
01624 {
01625         int value = 0;
01626 #ifdef SO_RCVBUF
01627         socklen_t len = sizeof(value);
01628         if (getsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&value, &len) == -1)
01629         {
01630                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01631         }
01632 #else
01633         Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
01634 #endif
01635         return value ? true : false;
01636 }
01637 
01638 
01639 #ifdef SO_RCVBUFFORCE
01640 bool Socket::SetSoRcvbufforce(int x)
01641 {
01642         if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUFFORCE, (char *)&x, sizeof(x)) == -1)
01643         {
01644                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01645                 return false;
01646         }
01647         return true;
01648 }
01649 #endif
01650 
01651 
01652 bool Socket::SetSoSndbuf(int x)
01653 {
01654 #ifdef SO_SNDBUF
01655         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&x, sizeof(x)) == -1)
01656         {
01657                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01658                 return false;
01659         }
01660         return true;
01661 #else
01662         Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
01663         return false;
01664 #endif
01665 }
01666 
01667 
01668 int Socket::SoSndbuf()
01669 {
01670         int value = 0;
01671 #ifdef SO_SNDBUF
01672         socklen_t len = sizeof(value);
01673         if (getsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&value, &len) == -1)
01674         {
01675                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01676         }
01677 #else
01678         Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
01679 #endif
01680         return value ? true : false;
01681 }
01682 
01683 
01684 #ifdef SO_SNDBUFFORCE
01685 bool Socket::SetSoSndbufforce(int x)
01686 {
01687         if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUFFORCE, (char *)&x, sizeof(x)) == -1)
01688         {
01689                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01690                 return false;
01691         }
01692         return true;
01693 }
01694 #endif
01695 
01696 
01697 #ifdef SO_TIMESTAMP
01698 bool Socket::SetSoTimestamp(bool x)
01699 {
01700         int optval = x ? 1 : 0;
01701         if (setsockopt(GetSocket(), SOL_SOCKET, SO_TIMESTAMP, (char *)&optval, sizeof(optval)) == -1)
01702         {
01703                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_TIMESTAMP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01704                 return false;
01705         }
01706         return true;
01707 }
01708 #endif
01709 
01710 
01711 int Socket::SoType()
01712 {
01713         int value = 0;
01714 #ifdef SO_TYPE
01715         socklen_t len = sizeof(value);
01716         if (getsockopt(GetSocket(), SOL_SOCKET, SO_TYPE, (char *)&value, &len) == -1)
01717         {
01718                 Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_TYPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
01719         }
01720 #else
01721         Handler().LogError(this, "socket option not available", 0, "SO_TYPE", LOG_LEVEL_INFO);
01722 #endif
01723         return value ? true : false;
01724 }
01725 
01726 
01727 #ifdef ENABLE_TRIGGERS
01728 void Socket::Subscribe(int id)
01729 {
01730         Handler().Subscribe(id, this);
01731 }
01732 
01733 
01734 void Socket::Unsubscribe(int id)
01735 {
01736         Handler().Unsubscribe(id, this);
01737 }
01738 
01739 
01740 void Socket::OnTrigger(int, const TriggerData&)
01741 {
01742 }
01743 
01744 
01745 void Socket::OnCancelled(int)
01746 {
01747 }
01748 #endif
01749 
01750 
01751 void Socket::SetTimeout(time_t secs)
01752 {
01753         if (!secs)
01754         {
01755                 Handler().AddList(m_socket, LIST_TIMEOUT, false);
01756                 return;
01757         }
01758         Handler().AddList(m_socket, LIST_TIMEOUT, true);
01759         m_timeout_start = time(NULL);
01760         m_timeout_limit = secs;
01761 }
01762 
01763 
01764 void Socket::OnTimeout()
01765 {
01766 }
01767 
01768 
01769 void Socket::OnConnectTimeout()
01770 {
01771 }
01772 
01773 
01774 bool Socket::Timeout(time_t tnow)
01775 {
01776         if (tnow - m_timeout_start > m_timeout_limit)
01777                 return true;
01778         return false;
01779 }
01780 
01781 
01782 #ifdef SOCKETS_NAMESPACE
01783 }
01784 #endif
Page, code, and content Copyright (C) 2007 by Anders Hedström
Generated for C++ Sockets by  doxygen 1.4.4