00001
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
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
00059 #ifdef _WIN32
00060 WSAInitializer Socket::m_winsock_init;
00061 #endif
00062
00063
00064 Socket::Socket(ISocketHandler& h)
00065
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
00141
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)
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
00174 Handler().LogError(this, "close", Errno, StrError(Errno), LOG_LEVEL_ERROR);
00175 }
00176 Handler().Set(m_socket, false, false, false);
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)
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
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
00904
00905
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
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
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