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