PageRenderTime 79ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 1ms

/system/jlib/jsocket.cpp

https://github.com/emuharemagic/HPCC-Platform
C++ | 5993 lines | 5423 code | 459 blank | 111 comment | 863 complexity | c2caf370a2f41ff6eb37f88a13a46a5a MD5 | raw file
    

  1. /*##############################################################################
    2. 

    3. 

  3.     HPCC SYSTEMS software Copyright (C) 2012 HPCC Systems.
    4. 

    5. 

  5.     Licensed under the Apache License, Version 2.0 (the "License");
    6. 

  6.     you may not use this file except in compliance with the License.
    7. 

  7.     You may obtain a copy of the License at
    8. 

    9. 

  9.        http://www.apache.org/licenses/LICENSE-2.0
    10. 

    11. 

  11.     Unless required by applicable law or agreed to in writing, software
    12. 

  12.     distributed under the License is distributed on an "AS IS" BASIS,
    13. 

  13.     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14. 

  14.     See the License for the specific language governing permissions and
    15. 

  15.     limitations under the License.
    16. 

  16. ############################################################################## */
    17. 

  17. 

  18. 

  19. // New IPv6 Version - IN PROGRESS
    20. 

  20. 

  21. /*
    22. 

  22.     TBD IPv6 connect 
    23. 

  23.     multicast
    24. 

  24.     look at loopback
    25. 

  25. */
    26. 

  26. 

  27. 

  28. #include "platform.h"
    29. 

  29. #ifdef _VER_C5
    30. 

  30. #include <clwclib.h>
    31. 

  31. #else
    32. 

  32. #include "platform.h"
    33. 

  33. #include <stdio.h>
    34. 

  34. #endif
    35. 

  35. #include <algorithm>
    36. 

  36. 

  37. #ifdef _WIN32
    38. 

  38. #define WIN32_LEAN_AND_MEAN
    39. 

  39. #include <windows.h>
    40. 

  40. #include <winsock2.h>
    41. 

  41. #include <ws2tcpip.h>
    42. 

  42. #include <signal.h>  
    43. 

  43. #else
    44. 

  44. #include <sys/types.h>
    45. 

  45. #include <sys/socket.h>
    46. 

  46. #include <netinet/tcp.h>
    47. 

  47. #include <netinet/in.h>
    48. 

  48. #include <arpa/inet.h>
    49. 

  49. #include <stddef.h>
    50. 

  50. #include <errno.h>
    51. 

  51. #include <net/if.h>
    52. 

  52. #endif
    53. 

  53. #include <limits.h>
    54. 

  54. 

  55. #include "jmutex.hpp"
    56. 

  56. #include "jsocket.hpp"
    57. 

  57. #include "jexcept.hpp"
    58. 

  58. #include "jio.hpp"
    59. 

  59. #include "jmisc.hpp"
    60. 

  60. #include "jthread.hpp"
    61. 

  61. #include "jqueue.tpp"
    62. 

  62. #include "jtime.hpp"
    63. 

  63. #include "jprop.hpp"
    64. 

  64. #include "jregexp.hpp"
    65. 

  65. #include "jdebug.hpp"
    66. 

  66. #include "build-config.h"
    67. 

  67. 

  68. // epoll only with linux
    69. 

  69. 

  70. #ifndef __linux__
    71. 

  71. # undef _HAS_EPOLL_SUPPORT
    72. 

  72. #else
    73. 

  73. # define _HAS_EPOLL_SUPPORT
    74. 

  74. # ifdef _HAS_EPOLL_SUPPORT
    75. 

  75. #  include <unistd.h>
    76. 

  76. #  include <sys/epoll.h>
    77. 

  77. #  ifndef EPOLLRDHUP
    78. 

  78. //  Centos 5.x bug - epoll.h does not define but its in the kernel
    79. 

  79. #   define EPOLLRDHUP 0x2000
    80. 

  80. #  endif
    81. 

  81. # endif
    82. 

  82. #endif
    83. 

  83. 

  84. // various options 
    85. 

  85. 

  86. #define CONNECT_TIMEOUT_REFUSED_WAIT    1000        // maximum to sleep on connect_timeout
    87. 

  87. #define TRACE_SLOW_BLOCK_TRANSFER   
    88. 

  88. 

  89. #define DEFAULT_CONNECT_TIME    (100*1000)      // for connect_wait
    90. 

  90. 

  91. 

  92. 

  93. #ifndef _WIN32 
    94. 

  94. #define BLOCK_POLLED_SINGLE_CONNECTS  // NB this is much slower in windows
    95. 

  95. #define CENTRAL_NODE_RANDOM_DELAY
    96. 

  96. #else
    97. 

  97. #define USERECVSEM      // to singlethread BF_SYNC_TRANSFER_PUSH 
    98. 

  98. #endif
    99. 

  99. 

  100. #ifdef _DEBUG
    101. 

  101. //#define SOCKTRACE
    102. 

  102. //#define EPOLLTRACE
    103. 

  103. #endif
    104. 

  104. 

  105. #ifdef _TESTING
    106. 

  106. #define _TRACE
    107. 

  107. #endif
    108. 

  108. 

  109. #ifdef _TRACE
    110. 

  110. #define THROWJSOCKEXCEPTION(exc) \
    111. 

  111.   { StringBuffer msg; \
    112. 

  112.     msg.appendf("Target: %s, Raised in: %s, line %d",tracename ,__FILE__, __LINE__); \
    113. 

  113.     IJSOCK_Exception *e = new SocketException(exc,msg.str());\
    114. 

  114.     throw e; }
    115. 

  115. #define THROWJSOCKEXCEPTION2(exc) \
    116. 

  116.   { StringBuffer msg; \
    117. 

  117.     msg.appendf("Raised in: %s, line %d",__FILE__, __LINE__); \
    118. 

  118.     IJSOCK_Exception *e = new SocketException(exc,msg.str());\
    119. 

  119.     throw e; }
    120. 

  120. #define LOGERR(err,ref,info) LogErr(err,ref,info,__LINE__,NULL)
    121. 

  121. #define LOGERR2(err,ref,info) LogErr(err,ref,info,__LINE__,tracename)
    122. 

  122.     
    123. 

  123. #else
    124. 

  124. #define THROWJSOCKEXCEPTION(exc) \
    125. 

  125.   { IJSOCK_Exception *e = new SocketException(exc);\
    126. 

  126.     throw e; }
    127. 

  127. #define THROWJSOCKEXCEPTION2(exc) THROWJSOCKEXCEPTION(exc)
    128. 

  128. #define LOGERR(err,ref,info)
    129. 

  129. #define LOGERR2(err,ref,info)
    130. 

  130. #endif
    131. 

  131. 

  132. 

  133. JSocketStatistics STATS;
    134. 

  134. static bool IP4only=false;              // slighly faster if we know no IPv6
    135. 

  135. static bool IP6preferred=false;         // e.g. for DNS and socket create
    136. 

  136. 

  137. IpSubNet PreferredSubnet(NULL,NULL);    // set this if you prefer a particular subnet for debugging etc
    138. 

  138.                                         // e.g. PreferredSubnet("192.168.16.0", "255.255.255.0")
    139. 

  139. 

  140. static atomic_t pre_conn_unreach_cnt = ATOMIC_INIT(0);    // global count of pre_connect() ENETUNREACH error
    141. 

  141. 

  142. #define IPV6_SERIALIZE_PREFIX (0x00ff00ff)
    143. 

  143. 

  144. inline void LogErr(unsigned err,unsigned ref,const char *info,unsigned lineno,const char *tracename)
    145. 

  145. {
    146. 

  146.     if (err) 
    147. 

  147.         PROGLOG("jsocket(%d,%d)%s%s err = %d%s%s",ref,lineno,
    148. 

  148.            (info&&*info)?" ":"",(info&&*info)?info:"",err,
    149. 

  149.            (tracename&&*tracename)?" : ":"",(tracename&&*tracename)?tracename:"");
    150. 

  150. }
    151. 

  151.     
    152. 

  152. 

  153. class jlib_thrown_decl SocketException: public CInterface, public IJSOCK_Exception
    154. 

  154. {
    155. 

  155. public:
    156. 

  156.     IMPLEMENT_IINTERFACE;
    157. 

  157. 

  158.     SocketException(int code,const char *_msg=NULL) : errcode(code) 
    159. 

  159.     {
    160. 

  160.         if (_msg) 
    161. 

  161.             msg = strdup(_msg);
    162. 

  162.         else
    163. 

  163.             msg = NULL;
    164. 

  164.     };
    165. 

  165.     ~SocketException() { free(msg); }
    166. 

  166.     
    167. 

  167.     int             errorCode() const { return errcode; }
    168. 

  168.     static StringBuffer & geterrormessage(int err,StringBuffer &str)
    169. 

  169.     {
    170. 

  170.         switch (err) {
    171. 

  171.         case JSOCKERR_ok:                        return str.append("ok");
    172. 

  172.         case JSOCKERR_not_opened:                return str.append("socket not opened");
    173. 

  173.         case JSOCKERR_bad_address:               return str.append("bad address");
    174. 

  174.         case JSOCKERR_connection_failed:         return str.append("connection failed");
    175. 

  175.         case JSOCKERR_broken_pipe:               return str.append("connection is broken");
    176. 

  176.         case JSOCKERR_graceful_close:            return str.append("connection closed other end");
    177. 

  177.         case JSOCKERR_invalid_access_mode:       return str.append("invalid access mode");
    178. 

  178.         case JSOCKERR_timeout_expired:           return str.append("timeout expired");
    179. 

  179.         case JSOCKERR_port_in_use:               return str.append("port in use");
    180. 

  180.         case JSOCKERR_cancel_accept:             return str.append("cancel accept");
    181. 

  181.         case JSOCKERR_connectionless_socket:     return str.append("connectionless socket");
    182. 

  182.         case JSOCKERR_handle_too_large:          return str.append("handle too large");
    183. 

  183.         case JSOCKERR_bad_netaddr:               return str.append("bad net addr");
    184. 

  184.         case JSOCKERR_ipv6_not_implemented:      return str.append("IPv6 not implemented");
    185. 

  185.         // OS errors
    186. 

  186. #ifdef _WIN32
    187. 

  187.         case WSAEINTR:              return str.append("WSAEINTR(10004) - Interrupted system call.");
    188. 

  188.         case WSAEBADF:              return str.append("WSAEBADF(10009) - Bad file number.");
    189. 

  189.         case WSAEACCES:             return str.append("WSAEACCES(10013) - Permission denied.");
    190. 

  190.         case WSAEFAULT:             return str.append("WSAEFAULT(10014) - Bad address.");
    191. 

  191.         case WSAEINVAL:             return str.append("WSAEINVAL(10022) - Invalid argument.");
    192. 

  192.         case WSAEMFILE:             return str.append("WSAEMFILE(10024) - Too many open files.");
    193. 

  193.         case WSAEWOULDBLOCK:        return str.append("WSAEWOULDBLOCK(10035) - Operation would block.");
    194. 

  194.         case WSAEINPROGRESS:        return str.append("WSAEINPROGRESS(10036) - Operation now in progress.");
    195. 

  195.         case WSAEALREADY:           return str.append("WSAEALREADY(10037) - Operation already in progress.");
    196. 

  196.         case WSAENOTSOCK:           return str.append("WSAENOTSOCK(10038) - Socket operation on nonsocket.");
    197. 

  197.         case WSAEDESTADDRREQ:       return str.append("WSAEDESTADDRREQ(10039) - Destination address required.");
    198. 

  198.         case WSAEMSGSIZE:           return str.append("WSAEMSGSIZE(10040) - Message too long.");
    199. 

  199.         case WSAEPROTOTYPE:         return str.append("WSAEPROTOTYPE(10041) - Protocol wrong type for socket.");
    200. 

  200.         case WSAENOPROTOOPT:        return str.append("WSAENOPROTOOPT(10042) - Protocol not available.");
    201. 

  201.         case WSAEPROTONOSUPPORT:    return str.append("WSAEPROTONOSUPPORT(10043) - Protocol not supported.");
    202. 

  202.         case WSAESOCKTNOSUPPORT:    return str.append("WSAESOCKTNOSUPPORT(10044) - Socket type not supported.");
    203. 

  203.         case WSAEOPNOTSUPP:         return str.append("WSAEOPNOTSUPP(10045) - Operation not supported on socket.");
    204. 

  204.         case WSAEPFNOSUPPORT:       return str.append("WSAEPFNOSUPPORT(10046) - Protocol family not supported.");
    205. 

  205.         case WSAEAFNOSUPPORT:       return str.append("WSAEAFNOSUPPORT(10047) - Address family not supported by protocol family.");
    206. 

  206.         case WSAEADDRINUSE:         return str.append("WSAEADDRINUSE(10048) - Address already in use.");
    207. 

  207.         case WSAEADDRNOTAVAIL:      return str.append("WSAEADDRNOTAVAIL(10049) - Cannot assign requested address.");
    208. 

  208.         case WSAENETDOWN:           return str.append("WSAENETDOWN(10050) - Network is down.");
    209. 

  209.         case WSAENETUNREACH:        return str.append("WSAENETUNREACH(10051) - Network is unreachable.");
    210. 

  210.         case WSAENETRESET:          return str.append("WSAENETRESET(10052) - Network dropped connection on reset.");
    211. 

  211.         case WSAECONNABORTED:       return str.append("WSAECONNABORTED(10053) - Software caused connection abort.");
    212. 

  212.         case WSAECONNRESET:         return str.append("WSAECONNRESET(10054) - Connection reset by peer.");
    213. 

  213.         case WSAENOBUFS:            return str.append("WSAENOBUFS(10055) - No buffer space available.");
    214. 

  214.         case WSAEISCONN:            return str.append("WSAEISCONN(10056) - Socket is already connected.");
    215. 

  215.         case WSAENOTCONN:           return str.append("WSAENOTCONN(10057) - Socket is not connected.");
    216. 

  216.         case WSAESHUTDOWN:          return str.append("WSAESHUTDOWN(10058) - Cannot send after socket shutdown.");
    217. 

  217.         case WSAETOOMANYREFS:       return str.append("WSAETOOMANYREFS(10059) - Too many references: cannot splice.");
    218. 

  218.         case WSAETIMEDOUT:          return str.append("WSAETIMEDOUT(10060) - Connection timed out.");
    219. 

  219.         case WSAECONNREFUSED:       return str.append("WSAECONNREFUSED(10061) - Connection refused.");
    220. 

  220.         case WSAELOOP:              return str.append("WSAELOOP(10062) - Too many levels of symbolic links.");
    221. 

  221.         case WSAENAMETOOLONG:       return str.append("WSAENAMETOOLONG(10063) - File name too long.");
    222. 

  222.         case WSAEHOSTDOWN:          return str.append("WSAEHOSTDOWN(10064) - Host is down.");
    223. 

  223.         case WSAEHOSTUNREACH:       return str.append("WSAEHOSTUNREACH(10065) - No route to host.");
    224. 

  224.         case WSASYSNOTREADY:        return str.append("WSASYSNOTREADY(10091) - The network subsystem is unusable.");
    225. 

  225.         case WSAVERNOTSUPPORTED:    return str.append("WSAVERNOTSUPPORTED(10092) - The Windows Sockets DLL cannot support this application.");
    226. 

  226.         case WSANOTINITIALISED:     return str.append("WSANOTINITIALISED(10093) - Winsock not initialized.");
    227. 

  227.         case WSAEDISCON:            return str.append("WSAEDISCON(10101) - Disconnect.");
    228. 

  228.         case WSAHOST_NOT_FOUND:     return str.append("WSAHOST_NOT_FOUND(11001) - Host not found.");
    229. 

  229.         case WSATRY_AGAIN:          return str.append("WSATRY_AGAIN(11002) - Nonauthoritative host not found.");
    230. 

  230.         case WSANO_RECOVERY:        return str.append("WSANO_RECOVERY(11003) - Nonrecoverable error.");
    231. 

  231.         case WSANO_DATA:            return str.append("WSANO_DATA(11004) - Valid name, no data record of requested type.");
    232. 

  232. #else
    233. 

  233.         case ENOTSOCK:              return str.append("ENOTSOCK - Socket operation on non-socket ");
    234. 

  234.         case EDESTADDRREQ:          return str.append("EDESTADDRREQ - Destination address required ");
    235. 

  235.         case EMSGSIZE:              return str.append("EMSGSIZE - Message too long ");
    236. 

  236.         case EPROTOTYPE:            return str.append("EPROTOTYPE - Protocol wrong type for socket ");
    237. 

  237.         case ENOPROTOOPT:           return str.append("ENOPROTOOPT - Protocol not available ");
    238. 

  238.         case EPROTONOSUPPORT:       return str.append("EPROTONOSUPPORT - Protocol not supported ");
    239. 

  239.         case ESOCKTNOSUPPORT:       return str.append("ESOCKTNOSUPPORT - Socket type not supported ");
    240. 

  240.         case EOPNOTSUPP:            return str.append("EOPNOTSUPP - Operation not supported on socket ");
    241. 

  241.         case EPFNOSUPPORT:          return str.append("EPFNOSUPPORT - Protocol family not supported ");
    242. 

  242.         case EAFNOSUPPORT:          return str.append("EAFNOSUPPORT - Address family not supported by protocol family ");
    243. 

  243.         case EADDRINUSE:            return str.append("EADDRINUSE - Address already in use ");
    244. 

  244.         case EADDRNOTAVAIL:         return str.append("EADDRNOTAVAIL - Can't assign requested address ");
    245. 

  245.         case ENETDOWN:              return str.append("ENETDOWN - Network is down ");
    246. 

  246.         case ENETUNREACH:           return str.append("ENETUNREACH - Network is unreachable ");
    247. 

  247.         case ENETRESET:             return str.append("ENETRESET - Network dropped connection because of reset ");
    248. 

  248.         case ECONNABORTED:          return str.append("ECONNABORTED - Software caused connection abort ");
    249. 

  249.         case ECONNRESET:            return str.append("ECONNRESET - Connection reset by peer ");
    250. 

  250.         case ENOBUFS:               return str.append("ENOBUFS - No buffer space available ");
    251. 

  251.         case EISCONN:               return str.append("EISCONN - Socket is already connected ");
    252. 

  252.         case ENOTCONN:              return str.append("ENOTCONN - Socket is not connected ");
    253. 

  253.         case ESHUTDOWN:             return str.append("ESHUTDOWN - Can't send after socket shutdown ");
    254. 

  254.         case ETOOMANYREFS:          return str.append("ETOOMANYREFS - Too many references: can't splice ");
    255. 

  255.         case ETIMEDOUT:             return str.append("ETIMEDOUT - Connection timed out ");
    256. 

  256.         case ECONNREFUSED:          return str.append("ECONNREFUSED - Connection refused ");
    257. 

  257.         case EHOSTDOWN:             return str.append("EHOSTDOWN - Host is down ");
    258. 

  258.         case EHOSTUNREACH:          return str.append("EHOSTUNREACH - No route to host ");
    259. 

  259.         case EWOULDBLOCK:           return str.append("EWOULDBLOCK - operation already in progress");
    260. 

  260.         case EINPROGRESS:           return str.append("EINPROGRESS - operation now in progress ");
    261. 

  261. #endif
    262. 

  262.         }
    263. 

  263.         IException *ose = MakeOsException(err);
    264. 

  264.         ose->errorMessage(str);
    265. 

  265.         ose->Release();
    266. 

  266.         return str;
    267. 

  267.     }   
    268. 

  268.     StringBuffer &  errorMessage(StringBuffer &str) const
    269. 

  269.     { 
    270. 

  270.         if (msg)
    271. 

  271.             return geterrormessage(errcode,str).append('\n').append(msg); 
    272. 

  272.         return geterrormessage(errcode,str); 
    273. 

  273.     }
    274. 

  274.     MessageAudience errorAudience() const 
    275. 

  275.     { 
    276. 

  276.         switch (errcode) {
    277. 

  277.         case JSOCKERR_port_in_use:               
    278. 

  278.             return MSGAUD_operator; 
    279. 

  279.         }
    280. 

  280.         return MSGAUD_user; 
    281. 

  281.     }
    282. 

  282. private:
    283. 

  283.     int     errcode;
    284. 

  284.     char *msg;
    285. 

  285. };
    286. 

  286. 

  287. IJSOCK_Exception *IPv6NotImplementedException(const char *filename,unsigned lineno)
    288. 

  288. {
    289. 

  289.     StringBuffer msg;
    290. 

  290.     msg.appendf("%s(%d)",filename,lineno);
    291. 

  291.     return new SocketException(JSOCKERR_ipv6_not_implemented,msg.str());
    292. 

  292. }
    293. 

  293. 

  294. struct MCASTREQ
    295. 

  295. {
    296. 

  296.    struct in_addr imr_multiaddr;   /* multicast group to join */
    297. 

  297.    struct in_addr imr_interface;   /* interface to join on    */
    298. 

  298.    MCASTREQ(const char *mcip)
    299. 

  299.    {
    300. 

  300.         imr_multiaddr.s_addr = inet_addr(mcip);
    301. 

  301.         imr_interface.s_addr = htonl(INADDR_ANY);
    302. 

  302. 

  303.    }
    304. 

  304. 

  305. };
    306. 

  306. 

  307. #ifdef __APPLE__
    308. 

  308. #ifndef MSG_NOSIGNAL
    309. 

  309. #define MSG_NOSIGNAL 0x4000
    310. 

  310. #endif
    311. 

  311. #endif
    312. 

  312. 

  313. #if defined( _WIN32)
    314. 

  314. #define T_SOCKET SOCKET
    315. 

  315. #define T_FD_SET fd_set
    316. 

  316. #define XFD_SETSIZE FD_SETSIZE
    317. 

  317. #define ETIMEDOUT WSAETIMEDOUT
    318. 

  318. #define ECONNREFUSED WSAECONNREFUSED
    319. 

  319. #define XFD_ZERO(s) FD_ZERO(s)
    320. 

  320. #define SEND_FLAGS 0
    321. 

  321. #define BADSOCKERR(err) ((err==WSAEBADF)||(err==WSAENOTSOCK))
    322. 

  322. #define CHECKSOCKRANGE(s)
    323. 

  323. #elif defined(__FreeBSD__) || defined(__APPLE__)
    324. 

  324. #define XFD_SETSIZE FD_SETSIZE
    325. 

  325. #define T_FD_SET fd_set
    326. 

  326. #define XFD_ZERO(s) FD_ZERO(s)
    327. 

  327. #define T_SOCKET int
    328. 

  328. #define SEND_FLAGS (MSG_NOSIGNAL)
    329. 

  329. #define BADSOCKERR(err) ((err==EBADF)||(err==ENOTSOCK))
    330. 

  330. #define CHECKSOCKRANGE(s)
    331. 

  331. #else
    332. 

  332. #define XFD_SETSIZE 32768
    333. 

  333. struct xfd_set { __fd_mask fds_bits[XFD_SETSIZE / __NFDBITS]; }; // define our own
    334. 

  334. // linux 64 bit
    335. 

  335. #ifdef __linux__
    336. 

  336. #ifdef __x86_64__
    337. 

  337. #undef __FDMASK
    338. 

  338. #define __FDMASK(d)     (1UL << ((d) % __NFDBITS))
    339. 

  339. #undef __FDELT
    340. 

  340. #define __FDELT(d)      ((d) / __NFDBITS)
    341. 

  341. #undef __FD_SET
    342. 

  342. #define __FD_SET(d, s)     (__FDS_BITS (s)[__FDELT(d)] |= __FDMASK(d))
    343. 

  343. #undef __FD_ISSET
    344. 

  344. #define __FD_ISSET(d, s)   ((__FDS_BITS (s)[__FDELT(d)] & __FDMASK(d)) != 0)
    345. 

  345. #endif
    346. 

  346. #define CHECKSOCKRANGE(s) { if (s>=XFD_SETSIZE) THROWJSOCKEXCEPTION2(JSOCKERR_handle_too_large); }
    347. 

  347. #endif
    348. 

  348. // end 64 bit
    349. 

  349. #define T_FD_SET xfd_set
    350. 

  350. #define XFD_ZERO(s) memset(s,0,sizeof(xfd_set))
    351. 

  351. #define T_SOCKET int
    352. 

  352. #define SEND_FLAGS (MSG_NOSIGNAL)
    353. 

  353. #define BADSOCKERR(err) ((err==EBADF)||(err==ENOTSOCK))
    354. 

  354. #endif
    355. 

  355. #ifdef CENTRAL_NODE_RANDOM_DELAY
    356. 

  356. static SocketEndpointArray CentralNodeArray;
    357. 

  357. #endif
    358. 

  358. enum SOCKETMODE { sm_tcp_server, sm_tcp, sm_udp_server, sm_udp, sm_multicast_server, sm_multicast};
    359. 

  359. 

  360. class CSocket: public CInterface, public ISocket
    361. 

  361. {
    362. 

  362. public:
    363. 

  363.     IMPLEMENT_IINTERFACE;
    364. 

  364. 

  365.     static          CriticalSection crit;
    366. 

  366. protected:
    367. 

  367.     friend class CSocketConnectWait;
    368. 

  368.     enum { ss_open, ss_shutdown, ss_close, ss_pre_open } state;
    369. 

  369.     T_SOCKET        sock;
    370. 

  370.     char*           hostname;   // host address
    371. 

  371.     unsigned short  hostport;   // host port
    372. 

  372.     SOCKETMODE      sockmode;
    373. 

  373.     IpAddress       targetip;
    374. 

  374.     SocketEndpoint  returnep;   // set by set_return_addr
    375. 

  375.     
    376. 

  376.     MCASTREQ    *   mcastreq;
    377. 

  377.     size32_t        nextblocksize;
    378. 

  378.     unsigned        blockflags;
    379. 

  379.     unsigned        blocktimeoutms;
    380. 

  380.     bool            owned;
    381. 

  381.     enum            {accept_not_cancelled, accept_cancel_pending, accept_cancelled} accept_cancel_state;
    382. 

  382.     bool            in_accept;
    383. 

  383.     bool            nonblocking;
    384. 

  384.     bool            nagling;
    385. 

  385.     static unsigned connectingcount;
    386. 

  386. #ifdef USERECVSEM
    387. 

  387.     static Semaphore receiveblocksem;
    388. 

  388.     bool            receiveblocksemowned; // owned by this socket
    389. 

  389. #endif
    390. 

  390. #ifdef _TRACE
    391. 

  391.     char        *   tracename;
    392. 

  392. #endif
    393. 

  393.     
    394. 

  394. public:
    395. 

  395.     void        open(int listen_queue_size,bool reuseports=false);
    396. 

  396.     bool        connect_timeout( unsigned timeout, bool noexception);
    397. 

  397.     void        connect_wait( unsigned timems);
    398. 

  398.     void        udpconnect();
    399. 

  399. 

  400.     void        read(void* buf, size32_t min_size, size32_t max_size, size32_t &size_read,unsigned timeoutsecs);
    401. 

  401.     void        readtms(void* buf, size32_t min_size, size32_t max_size, size32_t &size_read, unsigned timedelaysecs);
    402. 

  402.     void        read(void* buf, size32_t size);
    403. 

  403.     size32_t    write(void const* buf, size32_t size);
    404. 

  404.     size32_t    write_multiple(unsigned num,void const**buf, size32_t *size);
    405. 

  405.     size32_t    udp_write_to(SocketEndpoint &ep,void const* buf, size32_t size);
    406. 

  406.     void        close();
    407. 

  407.     void        errclose();
    408. 

  408.     bool        connectionless() { return (sockmode!=sm_tcp)&&(sockmode!=sm_tcp_server); }
    409. 

  409.     void        shutdown(unsigned mode);
    410. 

  410. 

  411.     ISocket*    accept(bool allowcancel);
    412. 

  412.     int         wait_read(unsigned timeout);
    413. 

  413.     int         wait_write(unsigned timeout);
    414. 

  414.     int         name(char *name,size32_t namemax);
    415. 

  415.     int         peer_name(char *name,size32_t namemax);
    416. 

  416.     SocketEndpoint &getPeerEndpoint(SocketEndpoint &ep);
    417. 

  417.     IpAddress & getPeerAddress(IpAddress &addr);
    418. 

  418.     void        set_return_addr(int port,const char *name);  // sets returnep
    419. 

  419.     void        cancel_accept();
    420. 

  420.     size32_t    get_max_send_size();
    421. 

  421.     bool        set_nonblock(bool on=true);
    422. 

  422.     bool        set_nagle(bool on);
    423. 

  423.     void        set_linger(int lingersecs); 
    424. 

  424.     void        set_keep_alive(bool set);
    425. 

  425.     virtual void set_inherit(bool inherit=false);
    426. 

  426.     virtual bool check_connection();
    427. 

  427. 

  428.     
    429. 

  429.     // Block functions
    430. 

  430.     void        set_block_mode(unsigned flags,size32_t recsize=0,unsigned timeoutms=0);
    431. 

  431.     bool        send_block(const void *blk,size32_t sz);
    432. 

  432.     size32_t        receive_block_size();
    433. 

  433.     size32_t        receive_block(void *blk,size32_t sz);
    434. 

  434. 

  435.     size32_t        get_send_buffer_size();
    436. 

  436.     void        set_send_buffer_size(size32_t sz);
    437. 

  437. 

  438.     bool        join_multicast_group(SocketEndpoint &ep);   // for udp multicast
    439. 

  439.     bool        leave_multicast_group(SocketEndpoint &ep);  // for udp multicast
    440. 

  440. 

  441.     size32_t        get_receive_buffer_size();
    442. 

  442.     void        set_receive_buffer_size(size32_t sz);
    443. 

  443. 

  444.     size32_t        avail_read();
    445. 

  445. 

  446.     int         pre_connect(bool block);
    447. 

  447.     int         post_connect();
    448. 

  448. 

  449.     CSocket(const SocketEndpoint &_ep,SOCKETMODE smode,const char *name);
    450. 

  450.     CSocket(T_SOCKET new_sock,SOCKETMODE smode,bool _owned);
    451. 

  451. 

  452.     virtual ~CSocket();
    453. 

  453. 

  454.     unsigned OShandle()
    455. 

  455.     {
    456. 

  456.         return (unsigned)sock;
    457. 

  457.     }
    458. 

  458. 

  459. private:
    460. 

  460. 

  461.     int closesock()
    462. 

  462.     {
    463. 

  463.         if (sock!=INVALID_SOCKET) {
    464. 

  464.             T_SOCKET s = sock;
    465. 

  465.             sock = INVALID_SOCKET;
    466. 

  466.             STATS.activesockets--;
    467. 

  467.     #ifdef SOCKTRACE
    468. 

  468.             PROGLOG("SOCKTRACE: Closing socket %x %d (%x)", s, s, this);
    469. 

  469.     #endif
    470. 

  470.     #ifdef _WIN32
    471. 

  471.             return ::closesocket(s);
    472. 

  472.     #else
    473. 

  473.             return ::close(s);
    474. 

  474.     #endif
    475. 

  475.         }
    476. 

  476.         else
    477. 

  477.             return 0;
    478. 

  478.     }
    479. 

  479. };
    480. 

  480. 

  481. CriticalSection CSocket::crit;
    482. 

  482. unsigned CSocket::connectingcount=0;
    483. 

  483. #ifdef USERECVSEM
    484. 

  484. Semaphore CSocket::receiveblocksem(2);
    485. 

  485. #endif
    486. 

  486. 

  487. 

  488. #ifdef _WIN32
    489. 

  489. class win_socket_library 
    490. 

  490. {
    491. 

  491.     static bool initdone; // to prevent dependancy probs very early on (e.g. jlog)
    492. 

  492. public:
    493. 

  493.     win_socket_library() { init(); }
    494. 

  494.     bool init()
    495. 

  495.     {
    496. 

  496.         if (initdone)
    497. 

  497.             return true;
    498. 

  498.         WSADATA wsa;
    499. 

  499.         if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
    500. 

  500.             if (WSAStartup(MAKEWORD(1, 1), &wsa) != 0) {
    501. 

  501.                 MessageBox(NULL,"Failed to initialize windows sockets","JLib Socket Error",MB_OK);
    502. 

  502.                 return false;
    503. 

  503.             }
    504. 

  504.         }
    505. 

  505.         initdone = true;
    506. 

  506.         return true;
    507. 

  507.     }
    508. 

  508.     ~win_socket_library() 
    509. 

  509.     {
    510. 

  510.         WSACleanup();
    511. 

  511.     }
    512. 

  512. };
    513. 

  513. 

  514. bool win_socket_library::initdone = false;
    515. 

  515. static win_socket_library ws32_lib;
    516. 

  516. 

  517. #define ERRNO() WSAGetLastError()
    518. 

  518. #define EADDRINUSE WSAEADDRINUSE
    519. 

  519. #define EINTRCALL WSAEINTR
    520. 

  520. #define ECONNRESET WSAECONNRESET
    521. 

  521. #define ECONNABORTED WSAECONNABORTED
    522. 

  522. #define ENOTCONN WSAENOTCONN
    523. 

  523. #define EWOULDBLOCK WSAEWOULDBLOCK
    524. 

  524. #define EINPROGRESS WSAEINPROGRESS
    525. 

  525. #define ENETUNREACH WSAENETUNREACH
    526. 

  526. #define ENOTSOCK WSAENOTSOCK
    527. 

  527. 

  528. 

  529. struct j_sockaddr_in6 {
    530. 

  530.     short   sin6_family;        /* AF_INET6 */
    531. 

  531.     u_short sin6_port;          /* Transport level port number */
    532. 

  532.     u_long  sin6_flowinfo;      /* IPv6 flow information */
    533. 

  533.     struct in_addr6 sin6_addr;  /* IPv6 address */
    534. 

  534.     u_long sin6_scope_id;       /* set of interfaces for a scope */
    535. 

  535. };
    536. 

  536. 

  537. typedef union {
    538. 

  538.     struct sockaddr sa;
    539. 

  539.     struct j_sockaddr_in6 sin6;
    540. 

  540.     struct sockaddr_in sin;
    541. 

  541. } J_SOCKADDR;
    542. 

  542. 

  543. #define DEFINE_SOCKADDR(name) J_SOCKADDR name; memset(&name,0,sizeof(J_SOCKADDR))
    544. 

  544. 

  545. 

  546. static int _inet_pton(int af, const char* src, void* dst)
    547. 

  547. {
    548. 

  548.     
    549. 

  549.     DEFINE_SOCKADDR(u);
    550. 

  550.     
    551. 

  551.     int address_length;
    552. 

  552.     
    553. 

  553.     switch (af) {
    554. 

  554.     case AF_INET:
    555. 

  555.         u.sin.sin_family    = AF_INET;
    556. 

  556.         address_length = sizeof (u.sin);
    557. 

  557.         break;
    558. 

  558.         
    559. 

  559.     case AF_INET6:
    560. 

  560.         u.sin6.sin6_family  = AF_INET6;
    561. 

  561.         address_length = sizeof (u.sin6);
    562. 

  562.         break;
    563. 

  563.         
    564. 

  564.     default:
    565. 

  565. #ifdef EAFNOSUPPORT
    566. 

  566.         errno = EAFNOSUPPORT;
    567. 

  567. #else
    568. 

  568.         errno = 52;
    569. 

  569. #endif
    570. 

  570.         return -1;
    571. 

  571.     }
    572. 

  572.     ws32_lib.init();
    573. 

  573.     int ret = WSAStringToAddress ((LPTSTR) src, af, NULL, &u.sa, &address_length);
    574. 

  574.     if (ret == 0) {
    575. 

  575.         switch (af) {
    576. 

  576.         case AF_INET:
    577. 

  577.             memcpy (dst, &u.sin.sin_addr, sizeof (struct in_addr));
    578. 

  578.             break;
    579. 

  579.             
    580. 

  580.         case AF_INET6:
    581. 

  581.             memcpy (dst, &u.sin6.sin6_addr, sizeof (u.sin6.sin6_addr));
    582. 

  582.             break;
    583. 

  583.         }
    584. 

  584.         return 1;
    585. 

  585.     }
    586. 

  586.     errno = WSAGetLastError();  
    587. 

  587.     // PROGLOG("errno = %d",errno);
    588. 

  588.     return 0;
    589. 

  589. }
    590. 

  590. 

  591. static const char * _inet_ntop (int af, const void *src, char *dst, socklen_t cnt)
    592. 

  592. {
    593. 

  593.     /* struct sockaddr can't accomodate struct sockaddr_in6. */
    594. 

  594.     DEFINE_SOCKADDR(u);
    595. 

  595. 

  596.     DWORD dstlen = cnt;
    597. 

  597.     size_t srcsize;
    598. 

  598.     
    599. 

  599.     memset(&u,0,sizeof(u));
    600. 

  600.     switch (af) {
    601. 

  601.     case AF_INET:
    602. 

  602.         u.sin.sin_family = AF_INET;
    603. 

  603.         u.sin.sin_addr = *(struct in_addr *) src;
    604. 

  604.         srcsize = sizeof (u.sin);
    605. 

  605.         break;
    606. 

  606.     case AF_INET6:
    607. 

  607.         u.sin6.sin6_family = AF_INET6;
    608. 

  608.         memcpy(&u.sin6.sin6_addr,src,sizeof(in_addr6));
    609. 

  609.         srcsize = sizeof (u.sin6);
    610. 

  610.         break;
    611. 

  611.     default:
    612. 

  612.         return NULL;
    613. 

  613.     }
    614. 

  614.     
    615. 

  615.     ws32_lib.init();
    616. 

  616.     if (WSAAddressToString (&u.sa, srcsize, NULL, dst, &dstlen) != 0) {
    617. 

  617.         errno = WSAGetLastError();
    618. 

  618.         return NULL;
    619. 

  619.     }
    620. 

  620.     return (const char *) dst;
    621. 

  621. }
    622. 

  622. 

  623. 

  624. int inet_aton (const char *name, struct in_addr *addr)
    625. 

  625. {
    626. 

  626.     addr->s_addr = inet_addr (name);
    627. 

  627.     return (addr->s_addr == (u_long)-1)?1:0;        // 255.255.255.255 has had it here
    628. 

  628. }
    629. 

  629. 

  630. 

  631. 

  632. #else
    633. 

  633. #define _inet_ntop inet_ntop
    634. 

  634. #define _inet_pton inet_pton
    635. 

  635. 

  636. #define in_addr6 in6_addr 
    637. 

  637. 

  638. typedef union {
    639. 

  639.     struct sockaddr sa;
    640. 

  640.     struct sockaddr_in6 sin6;
    641. 

  641.     struct sockaddr_in sin;
    642. 

  642. } J_SOCKADDR;
    643. 

  643. 

  644. #define DEFINE_SOCKADDR(name) J_SOCKADDR name; memset(&name,0,sizeof(J_SOCKADDR))
    645. 

  645. 

  646. 

  647. #define EINTRCALL EINTR
    648. 

  648. #define ERRNO() (errno)
    649. 

  649. #ifndef INADDR_NONE
    650. 

  650. #define INADDR_NONE (-1)
    651. 

  651. #endif
    652. 

  652. #endif
    653. 

  653. 

  654. #ifndef INET6_ADDRSTRLEN
    655. 

  655. #define INET6_ADDRSTRLEN 65
    656. 

  656. #endif
    657. 

  657. 

  658. 

  659. inline socklen_t setSockAddr(J_SOCKADDR &u, const IpAddress &ip,unsigned short port)
    660. 

  660. {
    661. 

  661.     if (!IP6preferred) {
    662. 

  662.         if (ip.getNetAddress(sizeof(in_addr),&u.sin.sin_addr)==sizeof(in_addr)) {
    663. 

  663.             u.sin.sin_family = AF_INET; 
    664. 

  664.             u.sin.sin_port = htons(port);
    665. 

  665.             return sizeof(u.sin);
    666. 

  666.         }
    667. 

  667.     }
    668. 

  668.     if (IP4only)
    669. 

  669.         IPV6_NOT_IMPLEMENTED();
    670. 

  670.     ip.getNetAddress(sizeof(in_addr6),&u.sin6.sin6_addr);
    671. 

  671.     u.sin6.sin6_family = AF_INET6; 
    672. 

  672.     u.sin6.sin6_port = htons(port);
    673. 

  673.     return sizeof(u.sin6);
    674. 

  674. }
    675. 

  675. 

  676. inline socklen_t setSockAddrAny(J_SOCKADDR &u, unsigned short port)
    677. 

  677. {
    678. 

  678.     if (IP6preferred) {
    679. 

  679. #ifdef _WIN32
    680. 

  680.         IN6ADDR_SETANY((PSOCKADDR_IN6)&u.sin6.sin6_addr);
    681. 

  681. #else
    682. 

  682.         memcpy(&u.sin6.sin6_addr,&in6addr_any,sizeof(in_addr6));
    683. 

  683. #endif
    684. 

  684.         u.sin6.sin6_family= AF_INET6;                           
    685. 

  685.         u.sin6.sin6_port = htons(port);
    686. 

  686.         return sizeof(u.sin6);
    687. 

  687.     }
    688. 

  688.     u.sin.sin_addr.s_addr = htonl(INADDR_ANY);
    689. 

  689.     u.sin.sin_family= AF_INET;                          
    690. 

  690.     u.sin.sin_port = htons(port);
    691. 

  691.     return sizeof(u.sin);
    692. 

  692. }
    693. 

  693. 

  694. inline void getSockAddrEndpoint(const J_SOCKADDR &u, socklen_t ul, SocketEndpoint &ep)
    695. 

  695. {
    696. 

  696.     if (ul==sizeof(u.sin)) {
    697. 

  697.         ep.setNetAddress(sizeof(in_addr),&u.sin.sin_addr);
    698. 

  698.         ep.port = htons(u.sin.sin_port); 
    699. 

  699.     }
    700. 

  700.     else {
    701. 

  701.         ep.setNetAddress(sizeof(in_addr6),&u.sin6.sin6_addr);
    702. 

  702.         ep.port = htons(u.sin6.sin6_port); 
    703. 

  703.     }
    704. 

  704. }
    705. 

  705. 

  706. 

  707. 

  708. /* might need fcntl(F_SETFL), or ioctl(FIONBIO) */
    709. 

  709. /* Posix.1g says fcntl */
    710. 

  710. 

  711. #if defined(O_NONBLOCK) 
    712. 

  712. 

  713. bool CSocket::set_nonblock(bool on)
    714. 

  714. {
    715. 

  715.     int flags = fcntl(sock, F_GETFL, 0);
    716. 

  716.     if (flags == -1)
    717. 

  717.         return nonblocking;
    718. 

  718.     if (on)
    719. 

  719.         flags |= O_NONBLOCK;
    720. 

  720.     else
    721. 

  721.         flags &= ~O_NONBLOCK;
    722. 

  722.     if (fcntl(sock, F_SETFL, flags)==0) {
    723. 

  723.         bool wasNonBlocking = nonblocking;
    724. 

  724.         nonblocking = on;
    725. 

  725.         return wasNonBlocking;
    726. 

  726.     }
    727. 

  727.     return nonblocking;
    728. 

  728. }
    729. 

  729. 

  730. 

  731. 

  732. #else
    733. 

  733. 

  734. bool CSocket::set_nonblock(bool on)
    735. 

  735. {
    736. 

  736. #ifdef _WIN32
    737. 

  737.     u_long yes = on?1:0;
    738. 

  738.     if (ioctlsocket(sock, FIONBIO, &yes)==0) {
    739. 

  739. #else
    740. 

  740.     int yes = on?1:0;
    741. 

  741.     if (ioctl(sock, FIONBIO, &yes)==0) {
    742. 

  742. #endif
    743. 

  743.         bool wasNonBlocking = nonblocking;
    744. 

  744.         nonblocking = on;
    745. 

  745.         return wasNonBlocking;
    746. 

  746.     }
    747. 

  747.     return nonblocking;
    748. 

  748. }
    749. 

  749. 

  750. #endif
    751. 

  751. 

  752. bool CSocket::set_nagle(bool on)
    753. 

  753. {
    754. 

  754.     bool ret = nagling;
    755. 

  755.     nagling = on;
    756. 

  756.     int enabled = !on;
    757. 

  757.     if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&enabled, sizeof(enabled)) != 0) {
    758. 

  758.         nagling = !on;
    759. 

  759.     }
    760. 

  760.     return ret;
    761. 

  761. }
    762. 

  762. 

  763. void CSocket::set_inherit(bool inherit)
    764. 

  764. {
    765. 

  765. #ifndef _WIN32
    766. 

  766.     long flag = fcntl(sock, F_GETFD);
    767. 

  767.     if(inherit)
    768. 

  768.         flag &= ~FD_CLOEXEC;
    769. 

  769.     else
    770. 

  770.         flag |= FD_CLOEXEC;
    771. 

  771.     fcntl(sock, F_SETFD, flag);
    772. 

  772. #endif
    773. 

  773. }
    774. 

  774. 

  775. size32_t CSocket::avail_read()
    776. 

  776. {
    777. 

  777. #ifdef _WIN32
    778. 

  778.     u_long avail;
    779. 

  779.     if (ioctlsocket(sock, FIONREAD, &avail)==0) 
    780. 

  780. #else
    781. 

  781.     int avail;
    782. 

  782.     if (ioctl(sock, FIONREAD, &avail)==0) 
    783. 

  783. #endif
    784. 

  784.         return (size32_t)avail;
    785. 

  785.     int err = ERRNO();
    786. 

  786.     LOGERR2(err,1,"avail_read");
    787. 

  787.     return 0;
    788. 

  788. }
    789. 

  789. 

  790. #define PRE_CONN_UNREACH_ELIM  100
    791. 

  791. 

  792. int CSocket::pre_connect (bool block)
    793. 

  793. {
    794. 

  794.     assertex(hostname);
    795. 

  795.     DEFINE_SOCKADDR(u);
    796. 

  796.     if (targetip.isNull()) {
    797. 

  797.         set_return_addr(hostport,hostname);
    798. 

  798.         targetip.ipset(returnep);
    799. 

  799.     }
    800. 

  800.     socklen_t ul = setSockAddr(u,targetip,hostport);
    801. 

  801.     sock = ::socket(u.sa.sa_family, SOCK_STREAM, targetip.isIp4()?0:PF_INET6);
    802. 

  802.     owned = true;
    803. 

  803.     state = ss_pre_open;            // will be set to open by post_connect
    804. 

  804.     if (sock == INVALID_SOCKET) {
    805. 

  805.         int err = ERRNO();
    806. 

  806.         THROWJSOCKEXCEPTION(err);
    807. 

  807.     }
    808. 

  808.     STATS.activesockets++;
    809. 

  809.     int err = 0;
    810. 

  810.     set_nonblock(!block);
    811. 

  811.     int rc = ::connect(sock, &u.sa, ul);
    812. 

  812.     if (rc==SOCKET_ERROR) {
    813. 

  813.         err = ERRNO();
    814. 

  814.         if ((err != EINPROGRESS)&&(err != EWOULDBLOCK)&&(err != ETIMEDOUT)&&(err!=ECONNREFUSED)) {   // handled by caller
    815. 

  815.             if (err != ENETUNREACH) {
    816. 

  816.                 atomic_set(&pre_conn_unreach_cnt, 0);
    817. 

  817.                 LOGERR2(err,1,"pre_connect");
    818. 

  818.             } else {
    819. 

  819.                 int ecnt = atomic_read(&pre_conn_unreach_cnt);
    820. 

  820.                 if (ecnt <= PRE_CONN_UNREACH_ELIM) {
    821. 

  821.                     atomic_inc(&pre_conn_unreach_cnt);
    822. 

  822.                     LOGERR2(err,1,"pre_connect network unreachable");
    823. 

  823.                 }
    824. 

  824.             }
    825. 

  825.         } else
    826. 

  826.             atomic_set(&pre_conn_unreach_cnt, 0);
    827. 

  827.     } else
    828. 

  828.         atomic_set(&pre_conn_unreach_cnt, 0);
    829. 

  829. #ifdef SOCKTRACE
    830. 

  830.     PROGLOG("SOCKTRACE: pre-connected socket%s %x %d (%x) err=%d", block?"(block)":"", sock, sock, (int)this, err);
    831. 

  831. #endif
    832. 

  832.     return err;
    833. 

  833. }
    834. 

  834. 

  835. int CSocket::post_connect ()
    836. 

  836. {
    837. 

  837.     set_nonblock(false);
    838. 

  838.     int err = 0;
    839. 

  839.     socklen_t  errlen = sizeof(err);
    840. 

  840.     int rc = getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&err, &errlen); // check for error
    841. 

  841.     if ((rc!=0)&&!err)
    842. 

  842.         err = ERRNO();  // some implementations of getsockopt duff
    843. 

  843.     if (err==0) {
    844. 

  844.         nagling = true;
    845. 

  845.         set_nagle(false);
    846. 

  846.         state = ss_open;
    847. 

  847.     }
    848. 

  848.     else if ((err!=ETIMEDOUT)&&(err!=ECONNREFUSED)) // handled by caller
    849. 

  849.         LOGERR2(err,1,"post_connect");
    850. 

  850.     return err;
    851. 

  851. }
    852. 

  852. 

  853. 

  854. void CSocket::open(int listen_queue_size,bool reuseports)
    855. 

  855. {
    856. 

  856.     if (IP6preferred)
    857. 

  857.         sock = ::socket(AF_INET6, connectionless()?SOCK_DGRAM:SOCK_STREAM, PF_INET6);
    858. 

  858.     else
    859. 

  859.         sock = ::socket(AF_INET, connectionless()?SOCK_DGRAM:SOCK_STREAM, 0);
    860. 

  860.     if (sock == INVALID_SOCKET) {
    861. 

  861.         THROWJSOCKEXCEPTION(ERRNO());
    862. 

  862.     }
    863. 

  863.     STATS.activesockets++;
    864. 

  864. 

  865. #ifdef SOCKTRACE
    866. 

  866.     PROGLOG("SOCKTRACE: opened socket %x %d (%x)", sock,sock,this);
    867. 

  867. #endif
    868. 

  868. 

  869.     if ((hostport==0)&&(sockmode==sm_udp)) {
    870. 

  870.         state = ss_open;
    871. 

  871. #ifdef SOCKTRACE
    872. 

  872.         PROGLOG("SOCKTRACE: opened socket return udp");
    873. 

  873. #endif
    874. 

  874.         set_inherit(false);
    875. 

  875.         return;
    876. 

  876.     }
    877. 

  877. 

  878. #ifndef _WIN32
    879. 

  879.     reuseports = true;  // for some reason linux requires reuse ports
    880. 

  880. #endif
    881. 

  881.     if (reuseports) {
    882. 

  882.         int on = 1;
    883. 

  883.         setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
    884. 

  884.     }
    885. 

  885. 

  886.     DEFINE_SOCKADDR(u);
    887. 

  887.     socklen_t  ul;
    888. 

  888.     if (hostname) {
    889. 

  889.         if (targetip.isNull()) {
    890. 

  890.             set_return_addr(hostport,hostname);
    891. 

  891.             targetip.ipset(returnep);
    892. 

  892.         }
    893. 

  893.         ul = setSockAddr(u,targetip,hostport);
    894. 

  894.     }
    895. 

  895.     else 
    896. 

  896.         ul = setSockAddrAny(u,hostport);
    897. 

  897.     int saverr;
    898. 

  898.     if (::bind(sock, &u.sa, ul) != 0) {
    899. 

  899.         saverr = ERRNO();
    900. 

  900.         if (saverr==EADDRINUSE) {   // don't log as error (some usages probe ports)
    901. 

  901. ErrPortInUse:
    902. 

  902.             closesock();
    903. 

  903.             char msg[1024]; 
    904. 

  904.             sprintf(msg,"Target: %s, port = %d, Raised in: %s, line %d",tracename,(int)hostport,__FILE__, __LINE__); 
    905. 

  905.             IJSOCK_Exception *e = new SocketException(JSOCKERR_port_in_use,msg);
    906. 

  906.             throw e; 
    907. 

  907.         }
    908. 

  908.         else {
    909. 

  909.             closesock();
    910. 

  910.             THROWJSOCKEXCEPTION(saverr);
    911. 

  911.         }
    912. 

  912.     }
    913. 

  913.     if (!connectionless()) {
    914. 

  914.         if (::listen(sock, listen_queue_size) != 0) {
    915. 

  915.             saverr = ERRNO();
    916. 

  916.             if (saverr==EADDRINUSE)
    917. 

  917.                 goto ErrPortInUse;
    918. 

  918.             closesock();
    919. 

  919.             THROWJSOCKEXCEPTION(saverr);
    920. 

  920.         }
    921. 

  921.     }
    922. 

  922.     if (mcastreq) {
    923. 

  923.         if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,(char*)mcastreq, sizeof(*mcastreq))!=0) {
    924. 

  924.             saverr = ERRNO();
    925. 

  925.             closesock();
    926. 

  926.             THROWJSOCKEXCEPTION(saverr);
    927. 

  927.         }
    928. 

  928.     }
    929. 

  929. 

  930.     state = ss_open;
    931. 

  931. #ifdef SOCKTRACE
    932. 

  932.     PROGLOG("SOCKTRACE: opened socket return");
    933. 

  933. #endif
    934. 

  934.     set_inherit(false);
    935. 

  935. }
    936. 

  936. 

  937. 

  938. 

  939. ISocket* CSocket::accept(bool allowcancel)
    940. 

  940. {
    941. 

  941.     if ((accept_cancel_state!=accept_not_cancelled) && allowcancel) {
    942. 

  942.         accept_cancel_state=accept_cancelled;
    943. 

  943.         return NULL;
    944. 

  944.     }
    945. 

  945.     if (state != ss_open) {
    946. 

  946.         ERRLOG("invalid accept, state = %d",(int)state);
    947. 

  947.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    948. 

  948.     }
    949. 

  949.     if (connectionless()) {
    950. 

  950.         THROWJSOCKEXCEPTION(JSOCKERR_connectionless_socket);
    951. 

  951.     }
    952. 

  952.     T_SOCKET newsock;
    953. 

  953.     loop {
    954. 

  954.         in_accept = true;
    955. 

  955.         newsock = (sock!=INVALID_SOCKET)?::accept(sock, NULL, NULL):INVALID_SOCKET;
    956. 

  956.         in_accept = false;
    957. 

  957.     #ifdef SOCKTRACE
    958. 

  958.         PROGLOG("SOCKTRACE: accept created socket %x %d (%x)", newsock,newsock,this);
    959. 

  959.     #endif
    960. 

  960. 

  961.         if (newsock!=INVALID_SOCKET) {
    962. 

  962.             if ((sock==INVALID_SOCKET)||(accept_cancel_state==accept_cancel_pending)) {
    963. 

  963.                 ::close(newsock);
    964. 

  964.                 newsock=INVALID_SOCKET;
    965. 

  965.             }
    966. 

  966.             else {
    967. 

  967.                 accept_cancel_state = accept_not_cancelled;
    968. 

  968.                 break;
    969. 

  969.             }
    970. 

  970.         }
    971. 

  971.         int saverr;
    972. 

  972.         saverr = ERRNO();
    973. 

  973.         if ((sock==INVALID_SOCKET)||(accept_cancel_state==accept_cancel_pending)) {
    974. 

  974.             accept_cancel_state = accept_cancelled;
    975. 

  975.             if (allowcancel)
    976. 

  976.                 return NULL;
    977. 

  977.             THROWJSOCKEXCEPTION(JSOCKERR_cancel_accept);
    978. 

  978.         }
    979. 

  979.         if (saverr != EINTRCALL) {
    980. 

  980.             accept_cancel_state = accept_not_cancelled;
    981. 

  981.             THROWJSOCKEXCEPTION(saverr);
    982. 

  982.         }
    983. 

  983.     }
    984. 

  984.     if (state != ss_open) {
    985. 

  985.         accept_cancel_state = accept_cancelled;
    986. 

  986.         if (allowcancel)
    987. 

  987.             return NULL;
    988. 

  988.         THROWJSOCKEXCEPTION(JSOCKERR_cancel_accept);
    989. 

  989.     }
    990. 

  990.     CSocket *ret = new CSocket(newsock,sm_tcp,true);
    991. 

  991.     ret->set_inherit(false);
    992. 

  992.     return ret;
    993. 

  993. 

  994. }
    995. 

  995. 

  996. 

  997. void CSocket::set_linger(int lingertime)
    998. 

  998. {
    999. 

  999.     struct linger l;
    1000. 

  1000.     l.l_onoff = (lingertime>=0)?1:0;
    1001. 

  1001.     l.l_linger = (lingertime>=0)?lingertime:0;
    1002. 

  1002.     if (setsockopt(sock, SOL_SOCKET, SO_LINGER, (char*)&l, sizeof(l)) != 0) {
    1003. 

  1003.         WARNLOG("Linger not set");
    1004. 

  1004.     }
    1005. 

  1005. }
    1006. 

  1006. 

  1007. void CSocket::set_keep_alive(bool set)
    1008. 

  1008. {
    1009. 

  1009.     int on=set?1:0;
    1010. 

  1010.     if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char*)&on, sizeof(on)) != 0) {
    1011. 

  1011.         WARNLOG("KeepAlive not set");
    1012. 

  1012.     }
    1013. 

  1013. }
    1014. 

  1014. 

  1015. 

  1016. int CSocket::name(char *retname,size32_t namemax)
    1017. 

  1017. {
    1018. 

  1018.     if (!retname)
    1019. 

  1019.         namemax = 0;
    1020. 

  1020.     if (namemax)
    1021. 

  1021.         retname[0] = 0;
    1022. 

  1022.     if (state != ss_open) {
    1023. 

  1023.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1024. 

  1024.     }
    1025. 

  1025.     DEFINE_SOCKADDR(u);
    1026. 

  1026.     socklen_t ul = sizeof(u);
    1027. 

  1027.     if (::getsockname(sock,&u.sa, &ul)<0) {
    1028. 

  1028.         THROWJSOCKEXCEPTION(ERRNO());
    1029. 

  1029.     }
    1030. 

  1030.     SocketEndpoint ep;
    1031. 

  1031.     getSockAddrEndpoint(u,ul,ep);
    1032. 

  1032.     if (namemax>=1)
    1033. 

  1033.     {
    1034. 

  1034.         StringBuffer s;
    1035. 

  1035.         ep.getIpText(s);
    1036. 

  1036.         if (namemax-1<s.length())
    1037. 

  1037.             s.setLength(namemax-1);
    1038. 

  1038.         memcpy(retname,s.str(),s.length()+1);
    1039. 

  1039.     }
    1040. 

  1040.     return ep.port;
    1041. 

  1041. }
    1042. 

  1042. 

  1043. int CSocket::peer_name(char *retname,size32_t namemax)
    1044. 

  1044. {
    1045. 

  1045.     // should not raise exceptions
    1046. 

  1046.     int ret = 0;
    1047. 

  1047.     if (!retname)
    1048. 

  1048.         namemax = 0;
    1049. 

  1049.     if (namemax)
    1050. 

  1050.         retname[0] = 0;
    1051. 

  1051.     if (state != ss_open) {
    1052. 

  1052.         return -1; // don't log as used to test socket
    1053. 

  1053.     }
    1054. 

  1054.     StringBuffer s;
    1055. 

  1055.     if (sockmode==sm_udp_server) { // udp server
    1056. 

  1056.         returnep.getIpText(s);
    1057. 

  1057.         ret =  returnep.port;
    1058. 

  1058.     }   
    1059. 

  1059.     else {
    1060. 

  1060.         DEFINE_SOCKADDR(u);
    1061. 

  1061.         socklen_t ul = sizeof(u);       
    1062. 

  1062.         if (::getpeername(sock,&u.sa, &ul)<0)           
    1063. 

  1063.             return -1;      // don't log as used to test socket
    1064. 

  1064.         SocketEndpoint ep;
    1065. 

  1065.         getSockAddrEndpoint(u,ul,ep);
    1066. 

  1066.         ep.getIpText(s);
    1067. 

  1067.         ret = ep.port;
    1068. 

  1068.     }
    1069. 

  1069.     if (namemax>1) {
    1070. 

  1070.         if (namemax-1<s.length())
    1071. 

  1071.             s.setLength(namemax-1);
    1072. 

  1072.         memcpy(retname,s.str(),s.length()+1);
    1073. 

  1073.     }
    1074. 

  1074.     return ret;
    1075. 

  1075. }
    1076. 

  1076. 

  1077. SocketEndpoint &CSocket::getPeerEndpoint(SocketEndpoint &ep)
    1078. 

  1078. {
    1079. 

  1079.     if (state != ss_open) {
    1080. 

  1080.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1081. 

  1081.     }
    1082. 

  1082.     StringBuffer s;
    1083. 

  1083.     if (sockmode==sm_udp_server) { // udp server
    1084. 

  1084.         ep.set(returnep);
    1085. 

  1085.     }   
    1086. 

  1086.     else {
    1087. 

  1087.         DEFINE_SOCKADDR(u);
    1088. 

  1088.         socklen_t ul = sizeof(u);       
    1089. 

  1089.         if (::getpeername(sock,&u.sa, &ul)<0) {         
    1090. 

  1090.             DBGLOG("getpeername failed %d",ERRNO());
    1091. 

  1091.             ep.set(NULL, 0);
    1092. 

  1092.         }
    1093. 

  1093.         else
    1094. 

  1094.             getSockAddrEndpoint(u,ul,ep);
    1095. 

  1095.     }
    1096. 

  1096.     return ep;
    1097. 

  1097. }
    1098. 

  1098. 

  1099. IpAddress & CSocket::getPeerAddress(IpAddress &addr)
    1100. 

  1100. {
    1101. 

  1101.     SocketEndpoint ep;
    1102. 

  1102.     getPeerEndpoint(ep);
    1103. 

  1103.     addr = ep;
    1104. 

  1104.     return addr;
    1105. 

  1105. }
    1106. 

  1106. 

  1107. void CSocket::set_return_addr(int port,const char *retname)
    1108. 

  1108. {
    1109. 

  1109.     if (!returnep.ipset(retname)) {
    1110. 

  1110.         IJSOCK_Exception *e = new SocketException(JSOCKERR_bad_address); // don't use THROWJSOCKEXCEPTION here
    1111. 

  1111.         throw e;
    1112. 

  1112.     }
    1113. 

  1113.     returnep.port = port;
    1114. 

  1114. }
    1115. 

  1115. 

  1116. 

  1117. 

  1118. void CSocket::cancel_accept()
    1119. 

  1119. {
    1120. 

  1120.     if (connectionless()) {
    1121. 

  1121.         THROWJSOCKEXCEPTION(JSOCKERR_connectionless_socket);
    1122. 

  1122.     }
    1123. 

  1123. #ifdef SOCKTRACE
    1124. 

  1124.     PROGLOG("SOCKTRACE: Cancel accept socket %x %d (%x)", sock, sock, this);
    1125. 

  1125. #endif
    1126. 

  1126.     if (!in_accept) {
    1127. 

  1127.         accept_cancel_state = accept_cancelled;
    1128. 

  1128.         errclose();
    1129. 

  1129.         return;
    1130. 

  1130.     }
    1131. 

  1131.     accept_cancel_state = accept_cancel_pending;
    1132. 

  1132.     errclose();     // this should cause accept to terminate (not supported on all linux though)
    1133. 

  1133. #ifdef _WIN32        
    1134. 

  1134.     for (unsigned i=0;i<5;i++) { // windows closes on different lower priority thread
    1135. 

  1135.         Sleep(i);
    1136. 

  1136.         if (accept_cancel_state==accept_cancelled) 
    1137. 

  1137.             return;
    1138. 

  1138.     }
    1139. 

  1139. #else
    1140. 

  1140.     Sleep(0);
    1141. 

  1141.     if (accept_cancel_state==accept_cancelled) 
    1142. 

  1142.         return;
    1143. 

  1143. #endif
    1144. 

  1144.     // Wakeup listener using a connection
    1145. 

  1145.     SocketEndpoint ep(hostport,queryHostIP());
    1146. 

  1146.     Owned<CSocket> sock = new CSocket(ep,sm_tcp,NULL);
    1147. 

  1147.     try {
    1148. 

  1148.         sock->connect_timeout(100,true);
    1149. 

  1149.     }
    1150. 

  1150.     catch (IJSOCK_Exception *e) { 
    1151. 

  1151.         EXCLOG(e,"CSocket::cancel_eccept");
    1152. 

  1152.         e->Release();                           
    1153. 

  1153.     }
    1154. 

  1154. }
    1155. 

  1155. 

  1156. 

  1157. // ================================================================================
    1158. 

  1158. // connect versions
    1159. 

  1159. 

  1160. ISocket*  ISocket::connect( const SocketEndpoint &ep )
    1161. 

  1161. {
    1162. 

  1162.     // general connect 
    1163. 

  1163.     return ISocket::connect_wait(ep,DEFAULT_CONNECT_TIME);
    1164. 

  1164. }
    1165. 

  1165. 

  1166. inline void refused_sleep(CTimeMon &tm, unsigned &refuseddelay)
    1167. 

  1167. {
    1168. 

  1168.     unsigned remaining;
    1169. 

  1169.     if (!tm.timedout(&remaining)) {
    1170. 

  1170.         if (refuseddelay<remaining/4) {
    1171. 

  1171.             Sleep(refuseddelay);
    1172. 

  1172.             if (refuseddelay<CONNECT_TIMEOUT_REFUSED_WAIT/2)
    1173. 

  1173.                 refuseddelay *=2;
    1174. 

  1174.             else
    1175. 

  1175.                 refuseddelay = CONNECT_TIMEOUT_REFUSED_WAIT;
    1176. 

  1176.         }
    1177. 

  1177.         else 
    1178. 

  1178.             Sleep(remaining/4); // towards end of timeout approach gradually
    1179. 

  1179.     }
    1180. 

  1180. }
    1181. 

  1181. 

  1182. bool CSocket::connect_timeout( unsigned timeout, bool noexception)
    1183. 

  1183. {
    1184. 

  1184.     // simple connect with timeout (no fancy stuff!)
    1185. 

  1185.     unsigned startt = usTick();
    1186. 

  1186.     CTimeMon tm(timeout);
    1187. 

  1187.     unsigned remaining;
    1188. 

  1188.     unsigned refuseddelay = 1;
    1189. 

  1189.     int err;
    1190. 

  1190.     while (!tm.timedout(&remaining)) {
    1191. 

  1191.         err = pre_connect(false);
    1192. 

  1192.         if ((err == EINPROGRESS)||(err == EWOULDBLOCK)) {
    1193. 

  1193.             T_FD_SET fds;
    1194. 

  1194.             struct timeval tv;
    1195. 

  1195.             XFD_ZERO(&fds);
    1196. 

  1196.             FD_SET((unsigned)sock, &fds);
    1197. 

  1197.             T_FD_SET except;
    1198. 

  1198.             XFD_ZERO(&except);
    1199. 

  1199.             FD_SET((unsigned)sock, &except);
    1200. 

  1200.             tv.tv_sec = remaining / 1000;
    1201. 

  1201.             tv.tv_usec = (remaining % 1000)*1000;
    1202. 

  1202.             CHECKSOCKRANGE(sock);
    1203. 

  1203.             int rc = ::select( sock + 1, NULL, (fd_set *)&fds, (fd_set *)&except, &tv );
    1204. 

  1204.             if (rc>0) {
    1205. 

  1205.                 // select succeeded - return error from socket (0 if connected)
    1206. 

  1206.                 socklen_t errlen = sizeof(err);
    1207. 

  1207.                 rc = getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&err, &errlen); // check for error
    1208. 

  1208.                 if ((rc!=0)&&!err) 
    1209. 

  1209.                     err = ERRNO();  // some implementations of getsockopt duff
    1210. 

  1210.                 if (err) //  probably ECONNREFUSED but treat all errors same
    1211. 

  1211.                     refused_sleep(tm,refuseddelay);
    1212. 

  1212.             }
    1213. 

  1213.             else if (rc<0) { 
    1214. 

  1214.                 err = ERRNO();
    1215. 

  1215.                 LOGERR2(err,2,"::select");
    1216. 

  1216.             }
    1217. 

  1217.         }
    1218. 

  1218.         if (err==0) {
    1219. 

  1219.             err = post_connect();
    1220. 

  1220.             if (err==0) {
    1221. 

  1221.                 STATS.connects++;
    1222. 

  1222.                 STATS.connecttime+=usTick()-startt;
    1223. 

  1223. #ifdef _TRACE
    1224. 

  1224.                 char peer[256];
    1225. 

  1225.                 peer[0] = 'C';
    1226. 

  1226.                 peer[1] = '!';
    1227. 

  1227.                 strcpy(peer+2,hostname?hostname:"(NULL)");
    1228. 

  1228.                 free(tracename);
    1229. 

  1229.                 tracename = strdup(peer);
    1230. 

  1230. #endif              
    1231. 

  1231.                 return true;
    1232. 

  1232.             }
    1233. 

  1233.         }
    1234. 

  1234.         errclose();
    1235. 

  1235.     }
    1236. 

  1236. #ifdef SOCKTRACE
    1237. 

  1237.     PROGLOG("connect_timeout: failed %d",err);
    1238. 

  1238. #endif
    1239. 

  1239.     STATS.failedconnects++;
    1240. 

  1240.     STATS.failedconnecttime+=usTick()-startt;
    1241. 

  1241.     if (!noexception)
    1242. 

  1242.         THROWJSOCKEXCEPTION(JSOCKERR_connection_failed);
    1243. 

  1243.     return false;
    1244. 

  1244. }
    1245. 

  1245. 

  1246. 

  1247. ISocket*  ISocket::connect_timeout(const SocketEndpoint &ep,unsigned timeout)
    1248. 

  1248. {
    1249. 

  1249.     if (ep.isNull()||(ep.port==0))
    1250. 

  1250.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    1251. 

  1251.     Owned<CSocket> sock = new CSocket(ep,sm_tcp,NULL);
    1252. 

  1252.     sock->connect_timeout(timeout,false);
    1253. 

  1253.     return sock.getClear();
    1254. 

  1254. }
    1255. 

  1255. 

  1256. #define POLLTIME 50
    1257. 

  1257. 

  1258. 

  1259. 

  1260. void CSocket::connect_wait(unsigned timems)
    1261. 

  1261. {
    1262. 

  1262.     // simple connect with timeout (no fancy stuff!)
    1263. 

  1263.     unsigned startt = usTick();
    1264. 

  1264.     CTimeMon tm(timems);
    1265. 

  1265.     bool exit = false;
    1266. 

  1266.     int err;
    1267. 

  1267.     unsigned refuseddelay = 1;
    1268. 

  1268.     while (!exit) {
    1269. 

  1269. #ifdef CENTRAL_NODE_RANDOM_DELAY
    1270. 

  1270.         ForEachItemIn(cn,CentralNodeArray) {
    1271. 

  1271.             SocketEndpoint &ep=CentralNodeArray.item(cn);
    1272. 

  1272.             if (ep.ipequals(targetip)) {
    1273. 

  1273.                 unsigned sleeptime = getRandom() % 1000;
    1274. 

  1274.                 StringBuffer s;
    1275. 

  1275.                 ep.getIpText(s);
    1276. 

  1276.                 PrintLog("Connection to central node %s - sleeping %d milliseconds", s.str(), sleeptime);
    1277. 

  1277.                 Sleep(sleeptime);           
    1278. 

  1278.                 break;
    1279. 

  1279.             }
    1280. 

  1280.         }
    1281. 

  1281. #endif
    1282. 

  1282.         unsigned remaining;
    1283. 

  1283.         exit = tm.timedout(&remaining);
    1284. 

  1284.         bool blockselect = exit;                            // if last time round block
    1285. 

  1285.         {
    1286. 

  1286.             CriticalBlock block(crit);
    1287. 

  1287.             if (++connectingcount>4)
    1288. 

  1288.                 blockselect = true;
    1289. 

  1289.         }
    1290. 

  1290.         err = pre_connect(blockselect);             
    1291. 

  1291.         if (blockselect) {
    1292. 

  1292.             if (err&&!exit)
    1293. 

  1293.                 refused_sleep(tm,refuseddelay); //  probably ECONNREFUSED but treat all errors same
    1294. 

  1294.         }
    1295. 

  1295.         else {
    1296. 

  1296.             unsigned timeoutms = (exit||(remaining<10000))?10000:remaining;
    1297. 

  1297.             unsigned polltime = 1;
    1298. 

  1298.             while (!blockselect && ((err == EINPROGRESS)||(err == EWOULDBLOCK))) {
    1299. 

  1299.                 T_FD_SET fds;
    1300. 

  1300.                 struct timeval tv;
    1301. 

  1301.                 XFD_ZERO(&fds);
    1302. 

  1302.                 FD_SET((unsigned)sock, &fds);
    1303. 

  1303.                 T_FD_SET except;
    1304. 

  1304.                 XFD_ZERO(&except);
    1305. 

  1305.                 FD_SET((unsigned)sock, &except);
    1306. 

  1306.     #ifdef BLOCK_POLLED_SINGLE_CONNECTS         
    1307. 

  1307.                 tv.tv_sec = timeoutms / 1000;
    1308. 

  1308.                 tv.tv_usec = (timeoutms % 1000)*1000;
    1309. 

  1309.     #else
    1310. 

  1310.                 tv.tv_sec = 0;
    1311. 

  1311.                 tv.tv_usec = 0;
    1312. 

  1312.     #endif
    1313. 

  1313.                 CHECKSOCKRANGE(sock);
    1314. 

  1314.                 int rc = ::select( sock + 1, NULL, (fd_set *)&fds, (fd_set *)&except, &tv );
    1315. 

  1315.                 if (rc>0) {
    1316. 

  1316.                     // select succeeded - return error from socket (0 if connected)
    1317. 

  1317.                     socklen_t errlen = sizeof(err);
    1318. 

  1318.                     rc = getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&err, &errlen); // check for error
    1319. 

  1319.                     if ((rc!=0)&&!err)
    1320. 

  1320.                         err = ERRNO();  // some implementations of getsockopt duff
    1321. 

  1321.                     if (err)
    1322. 

  1322.                         refused_sleep(tm,refuseddelay); //  probably ECONNREFUSED but treat all errors same
    1323. 

  1323.                     break;
    1324. 

  1324.                 }
    1325. 

  1325.                 if (rc<0) { 
    1326. 

  1326.                     err = ERRNO();
    1327. 

  1327.                     LOGERR2(err,2,"::select");
    1328. 

  1328.                     break;
    1329. 

  1329.                 }
    1330. 

  1330.                 if (!timeoutms) {
    1331. 

  1331.     #ifdef SOCKTRACE
    1332. 

  1332.                     PROGLOG("connecttimeout: timed out");
    1333. 

  1333.     #endif
    1334. 

  1334.                     err = -1;
    1335. 

  1335.                     break;
    1336. 

  1336.                 }
    1337. 

  1337.     #ifdef BLOCK_POLLED_SINGLE_CONNECTS 
    1338. 

  1338.                 break;
    1339. 

  1339.     #else
    1340. 

  1340.                 if (timeoutms<polltime)
    1341. 

  1341.                     polltime = timeoutms;
    1342. 

  1342.                 Sleep(polltime);                    // sleeps 1-50ms (to let other threads run)
    1343. 

  1343.                 timeoutms -= polltime;
    1344. 

  1344.                 if (polltime>POLLTIME/2)
    1345. 

  1345.                     polltime = POLLTIME;
    1346. 

  1346.                 else
    1347. 

  1347.                     polltime *= 2;
    1348. 

  1348.     #endif
    1349. 

  1349.             }
    1350. 

  1350.         }
    1351. 

  1351.         {
    1352. 

  1352.             CriticalBlock block(crit);
    1353. 

  1353.             --connectingcount;
    1354. 

  1354.         }
    1355. 

  1355.         if (err==0) {
    1356. 

  1356.             err = post_connect();
    1357. 

  1357.             if (err==0) {
    1358. 

  1358.                 STATS.connects++;
    1359. 

  1359.                 STATS.connecttime+=usTick()-startt;
    1360. 

  1360. #ifdef _TRACE
    1361. 

  1361.                 char peer[256];
    1362. 

  1362.                 peer[0] = 'C';
    1363. 

  1363.                 peer[1] = '!';
    1364. 

  1364.                 strcpy(peer+2,hostname?hostname:"(NULL)");
    1365. 

  1365.                 free(tracename);
    1366. 

  1366.                 tracename = strdup(peer);
    1367. 

  1367. #endif              
    1368. 

  1368.                 return;
    1369. 

  1369.             }
    1370. 

  1370.         }
    1371. 

  1371.         errclose();
    1372. 

  1372.     }
    1373. 

  1373. #ifdef SOCKTRACE
    1374. 

  1374.     PROGLOG("connect_wait: failed %d",err);
    1375. 

  1375. #endif
    1376. 

  1376.     STATS.failedconnects++;
    1377. 

  1377.     STATS.failedconnecttime+=usTick()-startt;
    1378. 

  1378.     THROWJSOCKEXCEPTION(JSOCKERR_connection_failed);
    1379. 

  1379. }
    1380. 

  1380. 

  1381. 

  1382. 

  1383. ISocket*  ISocket::connect_wait( const SocketEndpoint &ep, unsigned timems)
    1384. 

  1384. {
    1385. 

  1385.     if (ep.isNull()||(ep.port==0))
    1386. 

  1386.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    1387. 

  1387.     Owned<CSocket> sock = new CSocket(ep,sm_tcp,NULL);
    1388. 

  1388.     sock->connect_wait(timems);
    1389. 

  1389.     return sock.getClear();
    1390. 

  1390. }
    1391. 

  1391. 

  1392. 

  1393. 

  1394. void CSocket::udpconnect()
    1395. 

  1395. {
    1396. 

  1396.     DEFINE_SOCKADDR(u);
    1397. 

  1397.     if (targetip.isNull()) {
    1398. 

  1398.         set_return_addr(hostport,hostname);
    1399. 

  1399.         targetip.ipset(returnep);
    1400. 

  1400.     }
    1401. 

  1401.     socklen_t  ul = setSockAddr(u,targetip,hostport);
    1402. 

  1402.     sock = ::socket(u.sa.sa_family, SOCK_DGRAM, targetip.isIp4()?0:PF_INET6);
    1403. 

  1403. #ifdef SOCKTRACE
    1404. 

  1404.     PROGLOG("SOCKTRACE: udp connected socket %x %d (%x)", sock, sock, this);
    1405. 

  1405. #endif
    1406. 

  1406.     STATS.activesockets++;
    1407. 

  1407.     if (sock == INVALID_SOCKET) {
    1408. 

  1408.         THROWJSOCKEXCEPTION(ERRNO());
    1409. 

  1409.     }
    1410. 

  1410.     int res = ::connect(sock, &u.sa, ul);
    1411. 

  1411.     if (res != 0) { // works for UDP
    1412. 

  1412.         closesock();
    1413. 

  1413.         THROWJSOCKEXCEPTION(JSOCKERR_connection_failed);
    1414. 

  1414.     }
    1415. 

  1415.     nagling = false; // means nothing for UDP
    1416. 

  1416.     state = ss_open;
    1417. 

  1417. #ifdef _TRACE
    1418. 

  1418.     char peer[256];
    1419. 

  1419.     peer[0] = 'C';
    1420. 

  1420.     peer[1] = '!';
    1421. 

  1421.     strcpy(peer+2,hostname?hostname:"(NULL)");
    1422. 

  1422.     free(tracename);
    1423. 

  1423.     tracename = strdup(peer);
    1424. 

  1424. #endif
    1425. 

  1425. 

  1426. }
    1427. 

  1427. 

  1428. 

  1429. 

  1430. 

  1431. int CSocket::wait_read(unsigned timeout)
    1432. 

  1432. {
    1433. 

  1433.     int ret = 0;
    1434. 

  1434.     while (sock!=INVALID_SOCKET) {
    1435. 

  1435.         T_FD_SET fds;
    1436. 

  1436.         XFD_ZERO(&fds);
    1437. 

  1437.         FD_SET((unsigned)sock, &fds);
    1438. 

  1438.         CHECKSOCKRANGE(sock);
    1439. 

  1439.         if (timeout==WAIT_FOREVER) {
    1440. 

  1440.             ret = ::select( sock + 1, (fd_set *)&fds, NULL, NULL, NULL );
    1441. 

  1441.         }
    1442. 

  1442.         else {
    1443. 

  1443.             struct timeval tv;
    1444. 

  1444.             tv.tv_sec = timeout / 1000;
    1445. 

  1445.             tv.tv_usec = (timeout % 1000)*1000;
    1446. 

  1446.             ret = ::select( sock + 1, (fd_set *)&fds, NULL, NULL, &tv );
    1447. 

  1447.         }
    1448. 

  1448.         if (ret==SOCKET_ERROR) {
    1449. 

  1449.             int err = ERRNO();
    1450. 

  1450.             if (err!=EINTRCALL) {   // else retry (should adjust time but for our usage don't think it matters that much)
    1451. 

  1451.                 LOGERR2(err,1,"wait_read");
    1452. 

  1452.                 break;
    1453. 

  1453.             }
    1454. 

  1454.         }
    1455. 

  1455.         else
    1456. 

  1456.             break;
    1457. 

  1457.     }
    1458. 

  1458.     return ret;
    1459. 

  1459. }
    1460. 

  1460. 

  1461. int CSocket::wait_write(unsigned timeout)
    1462. 

  1462. {
    1463. 

  1463.     int ret = 0;
    1464. 

  1464.     while (sock!=INVALID_SOCKET) {
    1465. 

  1465.         T_FD_SET fds;
    1466. 

  1466.         XFD_ZERO(&fds);
    1467. 

  1467.         FD_SET((unsigned)sock, &fds);
    1468. 

  1468.         CHECKSOCKRANGE(sock);
    1469. 

  1469.         if (timeout==WAIT_FOREVER) {
    1470. 

  1470.             ret = ::select( sock + 1, NULL, (fd_set *)&fds, NULL, NULL );
    1471. 

  1471.         }
    1472. 

  1472.         else {
    1473. 

  1473.             struct timeval tv;
    1474. 

  1474.             tv.tv_sec = timeout / 1000;
    1475. 

  1475.             tv.tv_usec = (timeout % 1000)*1000;
    1476. 

  1476.             ret = ::select( sock + 1, NULL, (fd_set *)&fds, NULL, &tv );
    1477. 

  1477.         }
    1478. 

  1478.         if (ret==SOCKET_ERROR) {
    1479. 

  1479.             int err = ERRNO();
    1480. 

  1480.             if (err!=EINTRCALL) {   // else retry (should adjust time but for our usage don't think it matters that much)
    1481. 

  1481.                 LOGERR2(err,1,"wait_write");
    1482. 

  1482.                 break;
    1483. 

  1483.             }
    1484. 

  1484.         }
    1485. 

  1485.         else
    1486. 

  1486.             break;
    1487. 

  1487.     }
    1488. 

  1488.     return ret;
    1489. 

  1489. }
    1490. 

  1490. 

  1491. void CSocket::readtms(void* buf, size32_t min_size, size32_t max_size, size32_t &size_read,
    1492. 

  1492.                      unsigned timeoutms)
    1493. 

  1493. {
    1494. 

  1494.     if (timeoutms == WAIT_FOREVER) {
    1495. 

  1495.         read(buf,min_size, max_size, size_read,WAIT_FOREVER);
    1496. 

  1496.         return;
    1497. 

  1497.     }
    1498. 

  1498.         
    1499. 

  1499. 

  1500.     unsigned startt=usTick();
    1501. 

  1501.     size_read = 0;
    1502. 

  1502.     if (state != ss_open) {
    1503. 

  1503.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1504. 

  1504.     }
    1505. 

  1505.     unsigned start;
    1506. 

  1506.     unsigned timeleft;
    1507. 

  1507.     start = msTick();
    1508. 

  1508.     timeleft = timeoutms;
    1509. 

  1509. 

  1510.     do {
    1511. 

  1511.         int rc = wait_read(timeleft);
    1512. 

  1512.         if (rc < 0) {
    1513. 

  1513.             THROWJSOCKEXCEPTION(ERRNO());
    1514. 

  1514.         }
    1515. 

  1515.         if (rc == 0) {
    1516. 

  1516.             THROWJSOCKEXCEPTION(JSOCKERR_timeout_expired);
    1517. 

  1517.         }
    1518. 

  1518.         unsigned elapsed = (msTick()-start);
    1519. 

  1519.         if (elapsed<timeoutms)
    1520. 

  1520.             timeleft = timeoutms-elapsed;
    1521. 

  1521.         else
    1522. 

  1522.             timeleft = 0;
    1523. 

  1523.         unsigned retrycount=100;
    1524. 

  1524. EintrRetry:
    1525. 

  1525.         if (sockmode==sm_udp_server) { // udp server        
    1526. 

  1526.             DEFINE_SOCKADDR(u);
    1527. 

  1527.             socklen_t ul=sizeof(u);
    1528. 

  1528.             rc = recvfrom(sock, (char*)buf + size_read, max_size - size_read, 0, &u.sa,&ul);
    1529. 

  1529.             getSockAddrEndpoint(u,ul,returnep);
    1530. 

  1530.         }
    1531. 

  1531.         else {
    1532. 

  1532.             rc = recv(sock, (char*)buf + size_read, max_size - size_read, 0);
    1533. 

  1533.         }
    1534. 

  1534.         if (rc < 0) {
    1535. 

  1535.             int err = ERRNO();
    1536. 

  1536.             if (BADSOCKERR(err)) {
    1537. 

  1537.                 // don't think this should happen but convert to same as shutdown while investigation
    1538. 

  1538.                 LOGERR2(err,1,"Socket closed during read");
    1539. 

  1539.                 rc = 0;
    1540. 

  1540.             }
    1541. 

  1541.             else if ((err==EINTRCALL)&&(retrycount--!=0)) {
    1542. 

  1542.                 LOGERR2(err,1,"EINTR retrying");
    1543. 

  1543.                 goto EintrRetry;
    1544. 

  1544.             }
    1545. 

  1545.             else {
    1546. 

  1546.                 LOGERR2(err,1,"readtms");
    1547. 

  1547.                 if ((err==ECONNRESET)||(err==EINTRCALL)||(err==ECONNABORTED)) {
    1548. 

  1548.                     errclose();
    1549. 

  1549.                     err = JSOCKERR_broken_pipe;
    1550. 

  1550.                 }
    1551. 

  1551.                 THROWJSOCKEXCEPTION(err);
    1552. 

  1552.             }
    1553. 

  1553.         }
    1554. 

  1554.         if (rc == 0) {
    1555. 

  1555.             state = ss_shutdown;
    1556. 

  1556.             if (min_size==0) 
    1557. 

  1557.                 break;                      // if min_read is 0 return 0 if socket closed
    1558. 

  1558.             THROWJSOCKEXCEPTION(JSOCKERR_graceful_close);
    1559. 

  1559.         }
    1560. 

  1560.         size_read += rc;
    1561. 

  1561.     } while (size_read < min_size);
    1562. 

  1562.     STATS.reads++;
    1563. 

  1563.     STATS.readsize += size_read;
    1564. 

  1564.     STATS.readtime+=usTick()-startt;
    1565. 

  1565. 

  1566. }
    1567. 

  1567. 

  1568. void CSocket::read(void* buf, size32_t min_size, size32_t max_size, size32_t &size_read,
    1569. 

  1569.                      unsigned timeoutsecs)
    1570. 

  1570. {
    1571. 

  1571.     unsigned startt=usTick();
    1572. 

  1572.     size_read = 0;
    1573. 

  1573.     unsigned start;
    1574. 

  1574.     unsigned timeleft = 0;
    1575. 

  1575.     if (state != ss_open) {
    1576. 

  1576.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1577. 

  1577.     }
    1578. 

  1578.     if (timeoutsecs != WAIT_FOREVER) {
    1579. 

  1579.         start = (unsigned)time(NULL);
    1580. 

  1580.         timeleft = timeoutsecs;
    1581. 

  1581.     }
    1582. 

  1582. 

  1583.     do {
    1584. 

  1584.         int rc;
    1585. 

  1585.         if (timeoutsecs != WAIT_FOREVER) {
    1586. 

  1586.             rc = wait_read(timeleft*1000);
    1587. 

  1587.             if (rc < 0) {
    1588. 

  1588.                 THROWJSOCKEXCEPTION(ERRNO());
    1589. 

  1589.             }
    1590. 

  1590.             if (rc == 0) {
    1591. 

  1591.                 THROWJSOCKEXCEPTION(JSOCKERR_timeout_expired);
    1592. 

  1592.             }
    1593. 

  1593.             unsigned elapsed = ((unsigned)time(NULL))-start;
    1594. 

  1594.             if (elapsed<timeoutsecs)
    1595. 

  1595.                 timeleft = timeoutsecs-elapsed;
    1596. 

  1596.             else
    1597. 

  1597.                 timeleft = 0;
    1598. 

  1598.         }
    1599. 

  1599.         unsigned retrycount=100;
    1600. 

  1600. EintrRetry:
    1601. 

  1601.         if (sockmode==sm_udp_server) { // udp server
    1602. 

  1602.             DEFINE_SOCKADDR(u);
    1603. 

  1603.             socklen_t ul=sizeof(u.sin);     
    1604. 

  1604.             rc = recvfrom(sock, (char*)buf + size_read, max_size - size_read, 0, &u.sa,&ul);
    1605. 

  1605.             getSockAddrEndpoint(u,ul,returnep);
    1606. 

  1606.         }
    1607. 

  1607.         else {
    1608. 

  1608.             rc = recv(sock, (char*)buf + size_read, max_size - size_read, 0);
    1609. 

  1609.         }
    1610. 

  1610.         if (rc < 0) {
    1611. 

  1611.             int err = ERRNO();
    1612. 

  1612.             if (BADSOCKERR(err)) {
    1613. 

  1613.                 // don't think this should happen but convert to same as shutdown while investigation
    1614. 

  1614.                 LOGERR2(err,3,"Socket closed during read");
    1615. 

  1615.                 rc = 0;
    1616. 

  1616.             }
    1617. 

  1617.             else if ((err==EINTRCALL)&&(retrycount--!=0)) {
    1618. 

  1618.                 if (sock==INVALID_SOCKET)
    1619. 

  1619.                     rc = 0;         // convert an EINTR after closed to a graceful close
    1620. 

  1620.                 else {
    1621. 

  1621.                     LOGERR2(err,3,"EINTR retrying");
    1622. 

  1622.                     goto EintrRetry;
    1623. 

  1623.                 }
    1624. 

  1624.             }
    1625. 

  1625.             else {
    1626. 

  1626.                 LOGERR2(err,3,"read");
    1627. 

  1627.                 if ((err==ECONNRESET)||(err==EINTRCALL)||(err==ECONNABORTED)) {
    1628. 

  1628.                     errclose();
    1629. 

  1629.                     err = JSOCKERR_broken_pipe;
    1630. 

  1630.                 }
    1631. 

  1631.                 THROWJSOCKEXCEPTION(err);
    1632. 

  1632.             }
    1633. 

  1633.         }
    1634. 

  1634.         if (rc == 0) {
    1635. 

  1635.             state = ss_shutdown;
    1636. 

  1636.             if (min_size==0) 
    1637. 

  1637.                 break;                      // if min_read is 0 return 0 if socket closed
    1638. 

  1638.             THROWJSOCKEXCEPTION(JSOCKERR_graceful_close);
    1639. 

  1639.         }
    1640. 

  1640.         size_read += rc;
    1641. 

  1641.     } while (size_read < min_size);
    1642. 

  1642.     STATS.reads++;
    1643. 

  1643.     STATS.readsize += size_read;
    1644. 

  1644.     STATS.readtime+=usTick()-startt;
    1645. 

  1645. }
    1646. 

  1646. 

  1647. void CSocket::read(void* buf, size32_t size)
    1648. 

  1648. {
    1649. 

  1649.     if (!size)
    1650. 

  1650.         return;
    1651. 

  1651.     unsigned startt=usTick();
    1652. 

  1652.     size32_t size_read=size;
    1653. 

  1653.     if (state != ss_open) {
    1654. 

  1654.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1655. 

  1655.     }
    1656. 

  1656. 

  1657.     do {
    1658. 

  1658.         unsigned retrycount=100;
    1659. 

  1659. EintrRetry:
    1660. 

  1660.         int rc;
    1661. 

  1661.         if (sockmode==sm_udp_server) { // udp server
    1662. 

  1662.             DEFINE_SOCKADDR(u);
    1663. 

  1663.             socklen_t ul=sizeof(u.sin);
    1664. 

  1664.             rc = recvfrom(sock, (char*)buf, size, 0, &u.sa,&ul);
    1665. 

  1665.             getSockAddrEndpoint(u,ul,returnep);
    1666. 

  1666.         }
    1667. 

  1667.         else {
    1668. 

  1668.             rc = recv(sock, (char*)buf, size, 0);
    1669. 

  1669.         }
    1670. 

  1670.         if (rc < 0) {
    1671. 

  1671.             int err = ERRNO();
    1672. 

  1672.             if (BADSOCKERR(err)) {
    1673. 

  1673.                 // don't think this should happen but convert to same as shutdown while investigation
    1674. 

  1674.                 LOGERR2(err,5,"Socket closed during read");
    1675. 

  1675.                 rc = 0;
    1676. 

  1676.             }
    1677. 

  1677.             else if ((err==EINTRCALL)&&(retrycount--!=0)) {
    1678. 

  1678.                 LOGERR2(err,5,"EINTR retrying");
    1679. 

  1679.                 goto EintrRetry;
    1680. 

  1680.             }
    1681. 

  1681.             else {
    1682. 

  1682.                 LOGERR2(err,5,"read");
    1683. 

  1683.                 if ((err==ECONNRESET)||(err==EINTRCALL)||(err==ECONNABORTED)) {
    1684. 

  1684.                     errclose();
    1685. 

  1685.                     err = JSOCKERR_broken_pipe;
    1686. 

  1686.                 }
    1687. 

  1687.                 THROWJSOCKEXCEPTION(err);
    1688. 

  1688.             }
    1689. 

  1689.         }
    1690. 

  1690.         if (rc == 0) {
    1691. 

  1691.             state = ss_shutdown;
    1692. 

  1692.             THROWJSOCKEXCEPTION(JSOCKERR_graceful_close);
    1693. 

  1693.         }
    1694. 

  1694.         buf = (char*)buf + rc;
    1695. 

  1695.         size -= rc;
    1696. 

  1696.     } while (size != 0);
    1697. 

  1697.     STATS.reads++;
    1698. 

  1698.     STATS.readsize += size_read;
    1699. 

  1699.     STATS.readtime+=usTick()-startt;
    1700. 

  1700. 

  1701. }
    1702. 

  1702. 

  1703. 

  1704. 

  1705. size32_t CSocket::write(void const* buf, size32_t size)
    1706. 

  1706. {
    1707. 

  1707.     if (size==0)
    1708. 

  1708.         return 0;
    1709. 

  1709.     unsigned startt=usTick();
    1710. 

  1710.     size32_t size_writ = size;
    1711. 

  1711.     if (state != ss_open) {
    1712. 

  1712.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1713. 

  1713.     }
    1714. 

  1714.     size32_t res=0;
    1715. 

  1715.     do {
    1716. 

  1716.         unsigned retrycount=100;
    1717. 

  1717. EintrRetry:
    1718. 

  1718.         int rc;
    1719. 

  1719.         if (sockmode==sm_udp_server) { // udp server
    1720. 

  1720.             DEFINE_SOCKADDR(u);
    1721. 

  1721.             socklen_t  ul = setSockAddr(u,returnep,returnep.port);
    1722. 

  1722.             rc = sendto(sock, (char*)buf, size, 0, &u.sa, ul);
    1723. 

  1723.         }
    1724. 

  1724.         else {
    1725. 

  1725.             rc = send(sock, (char*)buf, size, SEND_FLAGS);
    1726. 

  1726.         }
    1727. 

  1727.         if (rc < 0) {
    1728. 

  1728.             int err=ERRNO();
    1729. 

  1729.             if (BADSOCKERR(err)) {
    1730. 

  1730.                 LOGERR2(err,7,"Socket closed during write");
    1731. 

  1731.                 rc = 0;
    1732. 

  1732.             }
    1733. 

  1733.             else if ((err==EINTRCALL)&&(retrycount--!=0)) {
    1734. 

  1734.                 LOGERR2(err,7,"EINTR retrying");
    1735. 

  1735.                 goto EintrRetry;
    1736. 

  1736.             }
    1737. 

  1737.             else {
    1738. 

  1738.                 if (((sockmode==sm_multicast)||(sockmode==sm_udp))&&(err==ECONNREFUSED))
    1739. 

  1739.                     break; // ignore
    1740. 

  1740.                 LOGERR2(err,7,"write");
    1741. 

  1741.                 if ((err==ECONNRESET)||(err==EINTRCALL)||(err==ECONNABORTED)
    1742. 

  1742. #ifndef _WIN32
    1743. 

  1743.                     ||(err==EPIPE)||(err==ETIMEDOUT)  // linux can raise these on broken pipe
    1744. 

  1744. #endif
    1745. 

  1745.                     ) {
    1746. 

  1746.                     errclose();
    1747. 

  1747.                     err = JSOCKERR_broken_pipe;
    1748. 

  1748.                 }
    1749. 

  1749.                 if ((err == EWOULDBLOCK) && nonblocking)
    1750. 

  1750.                     break;
    1751. 

  1751.                 THROWJSOCKEXCEPTION(err);
    1752. 

  1752.             }
    1753. 

  1753.         }   
    1754. 

  1754.         res += rc;
    1755. 

  1755.         if (rc == 0) {
    1756. 

  1756.             state = ss_shutdown;
    1757. 

  1757.             THROWJSOCKEXCEPTION(JSOCKERR_graceful_close);
    1758. 

  1758.         }
    1759. 

  1759.         if (nonblocking)
    1760. 

  1760.             break;
    1761. 

  1761.         buf = (char*)buf + rc;
    1762. 

  1762.         size -= rc;
    1763. 

  1763.     } while (size != 0);
    1764. 

  1764.     STATS.writes++;
    1765. 

  1765.     STATS.writesize += size_writ;
    1766. 

  1766.     STATS.writetime+=usTick()-startt;
    1767. 

  1767.     return res;
    1768. 

  1768. }
    1769. 

  1769. 

  1770. bool CSocket::check_connection()
    1771. 

  1771. {
    1772. 

  1772.     if (state != ss_open) 
    1773. 

  1773.         return false;
    1774. 

  1774. 

  1775.     unsigned retrycount=100;
    1776. 

  1776. EintrRetry:
    1777. 

  1777.     int rc;
    1778. 

  1778.     if (sockmode==sm_udp_server) { // udp server
    1779. 

  1779.         DEFINE_SOCKADDR(u);
    1780. 

  1780.         socklen_t  ul = setSockAddr(u,returnep,returnep.port);
    1781. 

  1781.         rc = sendto(sock, NULL, 0, 0, &u.sa, ul);
    1782. 

  1782.     }
    1783. 

  1783.     else {
    1784. 

  1784.         rc = send(sock, NULL, 0, SEND_FLAGS);
    1785. 

  1785.     }
    1786. 

  1786.     if (rc < 0) {
    1787. 

  1787.         int err=ERRNO();
    1788. 

  1788.         if ((err==EINTRCALL)&&(retrycount--!=0)) {
    1789. 

  1789.             LOGERR2(err,7,"EINTR retrying");
    1790. 

  1790.             goto EintrRetry;
    1791. 

  1791.         }
    1792. 

  1792.         else
    1793. 

  1793.             return false;
    1794. 

  1794.     }   
    1795. 

  1795.     return true;
    1796. 

  1796. }
    1797. 

  1797. 

  1798. size32_t CSocket::udp_write_to(SocketEndpoint &ep, void const* buf, size32_t size)
    1799. 

  1799. {
    1800. 

  1800.     if (size==0)
    1801. 

  1801.         return 0;
    1802. 

  1802.     unsigned startt=usTick();
    1803. 

  1803.     size32_t size_writ = size;
    1804. 

  1804.     if (state != ss_open) {
    1805. 

  1805.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1806. 

  1806.     }
    1807. 

  1807.     size32_t res=0;
    1808. 

  1808.     DEFINE_SOCKADDR(u); 
    1809. 

  1809.     loop {
    1810. 

  1810.         socklen_t  ul = setSockAddr(u,ep,ep.port);      
    1811. 

  1811.         int rc = sendto(sock, (char*)buf, size, 0, &u.sa, ul);
    1812. 

  1812.         if (rc < 0) {
    1813. 

  1813.             int err=ERRNO();
    1814. 

  1814.             if (((sockmode==sm_multicast)||(sockmode==sm_udp))&&(err==ECONNREFUSED))
    1815. 

  1815.                 break; // ignore
    1816. 

  1816.             if (err!=EINTRCALL) {
    1817. 

  1817.                 THROWJSOCKEXCEPTION(err);
    1818. 

  1818.             }
    1819. 

  1819.         }
    1820. 

  1820.         else {
    1821. 

  1821.             res = (size32_t)rc;
    1822. 

  1822.             break;
    1823. 

  1823.         }
    1824. 

  1824.     }
    1825. 

  1825.     STATS.writes++;
    1826. 

  1826.     STATS.writesize += res;
    1827. 

  1827.     STATS.writetime+=usTick()-startt;
    1828. 

  1828.     return res;
    1829. 

  1829. }
    1830. 

  1830. 

  1831. size32_t CSocket::write_multiple(unsigned num,const void **buf, size32_t *size)
    1832. 

  1832. {
    1833. 

  1833.     assertex(sockmode!=sm_udp_server);
    1834. 

  1834.     assertex(!nonblocking);
    1835. 

  1835.     if (num==1)
    1836. 

  1836.         return write(buf[0],size[0]);
    1837. 

  1837.     size32_t total = 0;
    1838. 

  1838.     unsigned i;
    1839. 

  1839.     for (i=0;i<num;i++)
    1840. 

  1840.         total += size[i];
    1841. 

  1841.     if (total==0)
    1842. 

  1842.         return 0;
    1843. 

  1843.     
    1844. 

  1844.     unsigned startt=usTick();
    1845. 

  1845.     if (state != ss_open) {
    1846. 

  1846.         THROWJSOCKEXCEPTION(JSOCKERR_not_opened);
    1847. 

  1847.     }
    1848. 

  1848.     size32_t res=0;
    1849. 

  1849. #ifdef _WIN32
    1850. 

  1850.     WSABUF *bufs = (WSABUF *)alloca(sizeof(WSABUF)*num);
    1851. 

  1851.     for (i=0;i<num;i++) {
    1852. 

  1852.         bufs[i].buf = (char *)buf[i];
    1853. 

  1853.         bufs[i].len = size[i];
    1854. 

  1854.     }
    1855. 

  1855.     unsigned retrycount=100;
    1856. 

  1856. EintrRetry:
    1857. 

  1857.     DWORD sent;
    1858. 

  1858.     if (WSASendTo(sock,bufs,num,&sent,0,NULL,0,NULL,NULL)==SOCKET_ERROR) {
    1859. 

  1859.         int err=ERRNO();
    1860. 

  1860.         if (BADSOCKERR(err)) {
    1861. 

  1861.             LOGERR2(err,8,"Socket closed during write");
    1862. 

  1862.             sent = 0;
    1863. 

  1863.         }
    1864. 

  1864.         else if ((err==EINTRCALL)&&(retrycount--!=0)) {
    1865. 

  1865.             LOGERR2(err,8,"EINTR retrying");
    1866. 

  1866.             goto EintrRetry;
    1867. 

  1867.         }
    1868. 

  1868.         else {
    1869. 

  1869.             LOGERR2(err,8,"write_multiple");
    1870. 

  1870.             if ((err==ECONNRESET)||(err==EINTRCALL)||(err==ECONNABORTED)||(err==ETIMEDOUT)) {
    1871. 

  1871.                 errclose();
    1872. 

  1872.                 err = JSOCKERR_broken_pipe;
    1873. 

  1873.             }
    1874. 

  1874.             THROWJSOCKEXCEPTION(err);
    1875. 

  1875.         }
    1876. 

  1876.     }   
    1877. 

  1877.     if (sent == 0) {
    1878. 

  1878.         state = ss_shutdown;
    1879. 

  1879.         THROWJSOCKEXCEPTION(JSOCKERR_graceful_close);
    1880. 

  1880.     }
    1881. 

  1881.     res = sent;
    1882. 

  1882. #else
    1883. 

  1883. #ifdef USE_CORK
    1884. 

  1884.     if (total>1024) {
    1885. 

  1885.         class Copt
    1886. 

  1886.         {
    1887. 

  1887.             T_SOCKET sock;
    1888. 

  1888.             bool nagling;
    1889. 

  1889.         public:
    1890. 

  1890.             Copt(T_SOCKET _sock,bool _nagling) 
    1891. 

  1891.             { 
    1892. 

  1892.                 nagling = _nagling;
    1893. 

  1893.                 int enabled = 1;
    1894. 

  1894.                 int disabled = 0;
    1895. 

  1895.                 if (!nagling) 
    1896. 

  1896.                     setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&disabled, sizeof(disabled));
    1897. 

  1897.                 setsockopt(sock, IPPROTO_TCP, TCP_CORK, (char*)&enabled, sizeof(enabled));
    1898. 

  1898.             }
    1899. 

  1899.             ~Copt() 
    1900. 

  1900.             { 
    1901. 

  1901.                 int enabled = 1;
    1902. 

  1902.                 int disabled = 0;
    1903. 

  1903.                 setsockopt(sock, IPPROTO_TCP, TCP_CORK, (char*)&disabled, sizeof(disabled));
    1904. 

  1904.                 if (!nagling) 
    1905. 

  1905.                     setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&enabled, sizeof(enabled));
    1906. 

  1906.             }
    1907. 

  1907.         } copt(sock,nagling);
    1908. 

  1908.         for (i=0;i<num;i++) 
    1909. 

  1909.             res += write(buf[i],size[i]);
    1910. 

  1910.     }
    1911. 

  1911.     else {
    1912. 

  1912.         byte b[1024];
    1913. 

  1913.         byte *p=b;
    1914. 

  1914.         for (i=0;i<num;i++) {
    1915. 

  1915.             memcpy(p,buf[i],size[i]);
    1916. 

  1916.             p += size[i];
    1917. 

  1917.         }
    1918. 

  1918.         res = write(b,total);
    1919. 

  1919.     }
    1920. 

  1920. #else
    1921. 

  1921.     // send in equal chunks about 64K
    1922. 

  1922.     unsigned n = (total+0xffff)/0x10000;
    1923. 

  1923.     size32_t outbufsize = (total+n-1)/n;
    1924. 

  1924.     MemoryAttr ma;
    1925. 

  1925.     byte *outbuf = (byte *)ma.allocate(outbufsize);
    1926. 

  1926.     size32_t outwr = 0;
    1927. 

  1927.     i = 0;
    1928. 

  1928.     size32_t os = 0;
    1929. 

  1929.     size32_t left = total;
    1930. 

  1930.     byte *b = NULL;
    1931. 

  1931.     size32_t s=0;
    1932. 

  1932.     loop {
    1933. 

  1933.         while (!s&&(i<num)) {
    1934. 

  1934.             b = (byte *)buf[i];
    1935. 

  1935.             s = size[i];
    1936. 

  1936.             i++;
    1937. 

  1937.         }
    1938. 

  1938.         if ((os==0)&&(s==left)) {
    1939. 

  1939.             write(b,s);     // go for it
    1940. 

  1940.             break;
    1941. 

  1941.         }
    1942. 

  1942.         else {
    1943. 

  1943.             size32_t cpy = outbufsize-os;
    1944. 

  1944.             if (cpy>s)
    1945. 

  1945.                 cpy = s;
    1946. 

  1946.             memcpy(outbuf+os,b,cpy);
    1947. 

  1947.             os += cpy;
    1948. 

  1948.             left -= cpy;
    1949. 

  1949.             s -= cpy;
    1950. 

  1950.             b += cpy;
    1951. 

  1951.             if (left==0)  {
    1952. 

  1952.                 write(outbuf,os);       
    1953. 

  1953.                 break;
    1954. 

  1954.             }
    1955. 

  1955.             else if (os==outbufsize) {
    1956. 

  1956.                 write(outbuf,os);   
    1957. 

  1957.                 os = 0;
    1958. 

  1958.             }
    1959. 

  1959.         }
    1960. 

  1960.     }
    1961. 

  1961. #endif
    1962. 

  1962. #endif
    1963. 

  1963.     STATS.writes++;
    1964. 

  1964.     STATS.writesize += res;
    1965. 

  1965.     STATS.writetime+=usTick()-startt;
    1966. 

  1966.     return res;
    1967. 

  1967. }
    1968. 

  1968. 

  1969. 

  1970. 

  1971. bool CSocket::send_block(const void *blk,size32_t sz)
    1972. 

  1972. {
    1973. 

  1973.     unsigned startt=usTick();
    1974. 

  1974. #ifdef TRACE_SLOW_BLOCK_TRANSFER
    1975. 

  1975.     unsigned startt2 = startt;
    1976. 

  1976.     unsigned startt3 = startt;
    1977. 

  1977. #endif
    1978. 

  1978.     if (blockflags&BF_SYNC_TRANSFER_PULL) {
    1979. 

  1979.         size32_t rd;
    1980. 

  1980.         bool eof = true;
    1981. 

  1981.         readtms(&eof,sizeof(eof),sizeof(eof),rd,blocktimeoutms);
    1982. 

  1982.         if (eof)
    1983. 

  1983.             return false;
    1984. 

  1984. #ifdef TRACE_SLOW_BLOCK_TRANSFER
    1985. 

  1985.         startt2=usTick();
    1986. 

  1986. #endif
    1987. 

  1987.     }
    1988. 

  1988.     if (!blk||!sz) {
    1989. 

  1989.         sz = 0;
    1990. 

  1990.         write(&sz,sizeof(sz));
    1991. 

  1991.         try {
    1992. 

  1992.             bool reply;
    1993. 

  1993.             size32_t rd;
    1994. 

  1994.             readtms(&reply,sizeof(reply),sizeof(reply),rd,blocktimeoutms);
    1995. 

  1995.         }
    1996. 

  1996.         catch (IJSOCK_Exception *e) { 
    1997. 

  1997.             if ((e->errorCode()!=JSOCKERR_broken_pipe)&&(e->errorCode()!=JSOCKERR_graceful_close)) 
    1998. 

  1998.                 EXCLOG(e,"CSocket::send_block");
    1999. 

  1999.             e->Release();                           
    2000. 

  2000.         }
    2001. 

  2001.         return false;
    2002. 

  2002.     }
    2003. 

  2003.     size32_t rsz=sz;
    2004. 

  2004.     _WINREV(rsz);
    2005. 

  2005.     write(&rsz,sizeof(rsz));
    2006. 

  2006.     if (blockflags&BF_SYNC_TRANSFER_PUSH) {
    2007. 

  2007. #ifdef TRACE_SLOW_BLOCK_TRANSFER
    2008. 

  2008.         startt2=usTick();
    2009. 

  2009. #endif
    2010. 

  2010.         size32_t rd;
    2011. 

  2011.         bool eof = true;
    2012. 

  2012.         readtms(&eof,sizeof(eof),sizeof(eof),rd,blocktimeoutms);
    2013. 

  2013.         if (eof)
    2014. 

  2014.             return false;
    2015. 

  2015. #ifdef TRACE_SLOW_BLOCK_TRANSFER
    2016. 

  2016.         startt3=usTick();
    2017. 

  2017. #endif
    2018. 

  2018.     }
    2019. 

  2019.     write(blk,sz);
    2020. 

  2020.     if (blockflags&BF_RELIABLE_TRANSFER) {
    2021. 

  2021.         bool isok=false;
    2022. 

  2022.         size32_t rd;
    2023. 

  2023.         readtms(&isok,sizeof(isok),sizeof(isok),rd,blocktimeoutms);
    2024. 

  2024.         if (!isok)
    2025. 

  2025.             return false;
    2026. 

  2026.     }
    2027. 

  2027.     unsigned nowt = usTick();
    2028. 

  2028.     unsigned elapsed = nowt-startt;
    2029. 

  2029.     STATS.blocksendtime+=elapsed;
    2030. 

  2030.     STATS.numblocksends++;
    2031. 

  2031.     STATS.blocksendsize+=sz;
    2032. 

  2032.     if (elapsed>STATS.longestblocksend) {
    2033. 

  2033.         STATS.longestblocksend = elapsed;
    2034. 

  2034.         STATS.longestblocksize = sz;
    2035. 

  2035.     }
    2036. 

  2036. #ifdef TRACE_SLOW_BLOCK_TRANSFER
    2037. 

  2037.     static unsigned lastreporttime=0;
    2038. 

  2038.     static unsigned lastexceeded=0;
    2039. 

  2039.     if (elapsed>1000000*60) { // over 1min
    2040. 

  2040.         unsigned t = msTick();
    2041. 

  2041.         if (1) { //((t-lastreporttime>1000*60) || // only report once per min
    2042. 

  2042.                  // (elapsed>lastexceeded*2)) {
    2043. 

  2043.             lastexceeded = elapsed;
    2044. 

  2044.             lastreporttime = t;
    2045. 

  2045.             WARNLOG("send_block took %ds to %s  (%d,%d,%d)",elapsed/1000000,tracename,startt2-startt,startt3-startt2,nowt-startt3);
    2046. 

  2046.         }
    2047. 

  2047.     }
    2048. 

  2048. #endif
    2049. 

  2049.     return true;
    2050. 

  2050. }
    2051. 

  2051. 

  2052. #ifdef USERECVSEM
    2053. 

  2053. 

  2054. class CSemProtect
    2055. 

  2055. {
    2056. 

  2056.     Semaphore *sem;
    2057. 

  2057.     bool *owned;
    2058. 

  2058. public:
    2059. 

  2059.     CSemProtect() { clear(); }
    2060. 

  2060.     ~CSemProtect() 
    2061. 

  2061.     { 
    2062. 

  2062.         if (sem&&*owned) {
    2063. 

  2063.             *owned = false;
    2064. 

  2064.             sem->signal(); 
    2065. 

  2065.         }
    2066. 

  2066.     }
    2067. 

  2067.     void set(Semaphore *_sem,bool *_owned)
    2068. 

  2068.     {
    2069. 

  2069.         sem = _sem;
    2070. 

  2070.         owned = _owned;
    2071. 

  2071.     }
    2072. 

  2072.     bool wait(Semaphore *_sem,bool *_owned,unsigned timeout) {
    2073. 

  2073.         if (!*_owned&&!_sem->wait(timeout))
    2074. 

  2074.             return false;
    2075. 

  2075.         *_owned = true;
    2076. 

  2076.         set(_sem,_owned);
    2077. 

  2077.         return true;
    2078. 

  2078.     }
    2079. 

  2079.     void clear() { sem = NULL; owned = NULL; }
    2080. 

  2080. };
    2081. 

  2081. #endif
    2082. 

  2082. 

  2083. size32_t CSocket::receive_block_size()
    2084. 

  2084. {
    2085. 

  2085.     // assumed always paired with receive_block
    2086. 

  2086.     if (nextblocksize) {
    2087. 

  2087.         if (blockflags&BF_SYNC_TRANSFER_PULL) {
    2088. 

  2088.             bool eof=false;
    2089. 

  2089.             write(&eof,sizeof(eof));
    2090. 

  2090.         }
    2091. 

  2091.         size32_t rd;
    2092. 

  2092.         readtms(&nextblocksize,sizeof(nextblocksize),sizeof(nextblocksize),rd,blocktimeoutms);
    2093. 

  2093.         _WINREV(nextblocksize);
    2094. 

  2094.         if (nextblocksize==0) { // confirm eof
    2095. 

  2095.             try {
    2096. 

  2096.                 bool confirm=true;
    2097. 

  2097.                 write(&confirm,sizeof(confirm));
    2098. 

  2098.             }
    2099. 

  2099.             catch (IJSOCK_Exception *e) { 
    2100. 

  2100.                 if ((e->errorCode()!=JSOCKERR_broken_pipe)&&(e->errorCode()!=JSOCKERR_graceful_close)) 
    2101. 

  2101.                     EXCLOG(e,"receive_block_size");
    2102. 

  2102.                 e->Release();                           
    2103. 

  2103.             }
    2104. 

  2104.         }
    2105. 

  2105.         else if (blockflags&BF_SYNC_TRANSFER_PUSH) {  // leaves receiveblocksem clear
    2106. 

  2106. #ifdef USERECVSEM
    2107. 

  2107.             CSemProtect semprot; // this will catch exception in write
    2108. 

  2108.             while (!semprot.wait(&receiveblocksem,&receiveblocksemowned,60*1000*5))
    2109. 

  2109.                 WARNLOG("Receive block stalled");
    2110. 

  2110. #endif
    2111. 

  2111.             bool eof=false;
    2112. 

  2112.             write(&eof,sizeof(eof));
    2113. 

  2113. #ifdef USERECVSEM
    2114. 

  2114.             semprot.clear();
    2115. 

  2115. #endif
    2116. 

  2116.         }
    2117. 

  2117. 

  2118.     }
    2119. 

  2119.     return nextblocksize;
    2120. 

  2120. }
    2121. 

  2121. 

  2122.     
    2123. 

  2123. size32_t CSocket::receive_block(void *blk,size32_t maxsize)
    2124. 

  2124. {
    2125. 

  2125. #ifdef USERECVSEM
    2126. 

  2126.     CSemProtect semprot; // this will catch exceptions
    2127. 

  2127. #endif
    2128. 

  2128.     size32_t sz = nextblocksize;
    2129. 

  2129.     if (sz) {
    2130. 

  2130.         if (sz==UINT_MAX) { // need to get size
    2131. 

  2131.             if (!blk||!maxsize) {
    2132. 

  2132.                 if (blockflags&BF_SYNC_TRANSFER_PUSH) { // ignore block size
    2133. 

  2133.                     size32_t rd;
    2134. 

  2134.                     readtms(&nextblocksize,sizeof(nextblocksize),sizeof(nextblocksize),rd,blocktimeoutms);
    2135. 

  2135.                 }
    2136. 

  2136.                 if (blockflags&(BF_SYNC_TRANSFER_PULL|BF_SYNC_TRANSFER_PUSH)) { // signal eof
    2137. 

  2137.                     bool eof=true;
    2138. 

  2138.                     write(&eof,sizeof(eof));
    2139. 

  2139.                     nextblocksize = 0;
    2140. 

  2140.                     return 0;
    2141. 

  2141.                 }
    2142. 

  2142.             }
    2143. 

  2143.             sz = receive_block_size();
    2144. 

  2144.             if (!sz) 
    2145. 

  2145.                 return 0;
    2146. 

  2146.         }
    2147. 

  2147.         unsigned startt=usTick();   // include sem block but not initial handshake
    2148. 

  2148. #ifdef USERECVSEM
    2149. 

  2149.         if (blockflags&BF_SYNC_TRANSFER_PUSH)  // read_block_size sets semaphore
    2150. 

  2150.             semprot.set(&receiveblocksem,&receiveblocksemowned);  // this will reset semaphore on exit
    2151. 

  2151. #endif
    2152. 

  2152.         nextblocksize = UINT_MAX;
    2153. 

  2153.         size32_t rd;
    2154. 

  2154.         if (sz<=maxsize) {
    2155. 

  2155.             readtms(blk,sz,sz,rd,blocktimeoutms);
    2156. 

  2156.         }
    2157. 

  2157.         else { // truncate
    2158. 

  2158.             readtms(blk,maxsize,maxsize,rd,blocktimeoutms);
    2159. 

  2159.             sz -= maxsize;
    2160. 

  2160.             void *tmp=malloc(sz);
    2161. 

  2161.             readtms(tmp,sz,sz,rd,blocktimeoutms);
    2162. 

  2162.             free(tmp);
    2163. 

  2163.             sz = maxsize;
    2164. 

  2164.         }
    2165. 

  2165.         if (blockflags&BF_RELIABLE_TRANSFER) {
    2166. 

  2166.             bool isok=true;
    2167. 

  2167.             write(&isok,sizeof(isok));
    2168. 

  2168.         }
    2169. 

  2169.         unsigned elapsed = usTick()-startt;
    2170. 

  2170.         STATS.blockrecvtime+=elapsed;
    2171. 

  2171.         STATS.numblockrecvs++;
    2172. 

  2172.         STATS.blockrecvsize+=sz;
    2173. 

  2173.     }
    2174. 

  2174.     return sz;
    2175. 

  2175. }
    2176. 

  2176. 

  2177. void CSocket::set_block_mode(unsigned flags, size32_t recsize, unsigned _timeoutms)
    2178. 

  2178. {
    2179. 

  2179.     blockflags = flags;
    2180. 

  2180.     nextblocksize = UINT_MAX;
    2181. 

  2181.     blocktimeoutms = _timeoutms?_timeoutms:WAIT_FOREVER;
    2182. 

  2182. }
    2183. 

  2183. 

  2184. 

  2185. 

  2186. void CSocket::shutdown(unsigned mode)
    2187. 

  2187. {
    2188. 

  2188.     if (state == ss_open) {
    2189. 

  2189.         state = ss_shutdown;
    2190. 

  2190. #ifdef SOCKTRACE
    2191. 

  2191.         PROGLOG("SOCKTRACE: shutdown(%d) socket %x %d (%x)", mode, sock, sock, this);
    2192. 

  2192. #endif
    2193. 

  2193.         int rc = ::shutdown(sock, mode);
    2194. 

  2194.         if (rc != 0) {
    2195. 

  2195.             int err=ERRNO();
    2196. 

  2196.             if (err==ENOTCONN) {
    2197. 

  2197.                 LOGERR2(err,9,"shutdown");
    2198. 

  2198.                 err = JSOCKERR_broken_pipe;
    2199. 

  2199.             }
    2200. 

  2200.             THROWJSOCKEXCEPTION(err);
    2201. 

  2201.         }
    2202. 

  2202.     }
    2203. 

  2203. }
    2204. 

  2204. 

  2205. void CSocket::errclose()
    2206. 

  2206. {
    2207. 

  2207. #ifdef USERECVSEM
    2208. 

  2208.     if (receiveblocksemowned) {
    2209. 

  2209.         receiveblocksemowned = false;
    2210. 

  2210.         receiveblocksem.signal();
    2211. 

  2211.     }
    2212. 

  2212. #endif
    2213. 

  2213.     if (state != ss_close) {
    2214. 

  2214.         state = ss_close;
    2215. 

  2215. #ifdef SOCKTRACE
    2216. 

  2216.         PROGLOG("SOCKTRACE: errclose socket %x %d (%x)", sock, sock, this);
    2217. 

  2217. #endif
    2218. 

  2218.         if (mcastreq)
    2219. 

  2219.             setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,(char*)mcastreq,sizeof(*mcastreq));
    2220. 

  2220.         closesock();
    2221. 

  2221.     }
    2222. 

  2222. }
    2223. 

  2223. 

  2224. 

  2225. void CSocket::close()
    2226. 

  2226. {
    2227. 

  2227. #ifdef USERECVSEM
    2228. 

  2228.     if (receiveblocksemowned) {
    2229. 

  2229.         receiveblocksemowned = false;
    2230. 

  2230.         receiveblocksem.signal();
    2231. 

  2231.     }
    2232. 

  2232. #endif
    2233. 

  2233.     if (state != ss_close) {
    2234. 

  2234. #ifdef SOCKTRACE
    2235. 

  2235.         PROGLOG("SOCKTRACE: close socket %x %d (%x)", sock, sock, this);
    2236. 

  2236. #endif
    2237. 

  2237.         state = ss_close;
    2238. 

  2238.         if (mcastreq)
    2239. 

  2239.             setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,(char*)mcastreq,sizeof(*mcastreq));
    2240. 

  2240.         if (closesock() != 0) {
    2241. 

  2241.             THROWJSOCKEXCEPTION(ERRNO());
    2242. 

  2242.         }
    2243. 

  2243.     }
    2244. 

  2244. }
    2245. 

  2245. 

  2246. size32_t CSocket::get_max_send_size()
    2247. 

  2247. {
    2248. 

  2248.     size32_t maxsend=0;
    2249. 

  2249.     socklen_t size = sizeof(maxsend);
    2250. 

  2250. #if _WIN32
    2251. 

  2251.     getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *) &maxsend, &size);
    2252. 

  2252. #else
    2253. 

  2253.     getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *) &maxsend, &size);  // not the same but closest I can find
    2254. 

  2254. #endif
    2255. 

  2255.   return maxsend;
    2256. 

  2256. }
    2257. 

  2257. 

  2258. 

  2259. size32_t CSocket::get_send_buffer_size()
    2260. 

  2260. {
    2261. 

  2261.     size32_t maxsend=0;
    2262. 

  2262.     socklen_t size = sizeof(maxsend);
    2263. 

  2263.     getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *) &maxsend, &size);  
    2264. 

  2264.     return maxsend;
    2265. 

  2265. }
    2266. 

  2266. 

  2267. 

  2268. void CSocket::set_send_buffer_size(size32_t maxsend)
    2269. 

  2269. {
    2270. 

  2270.     if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&maxsend, sizeof(maxsend))!=0) {
    2271. 

  2271.         LOGERR2(ERRNO(),1,"setsockopt(SO_SNDBUF)");
    2272. 

  2272.     }
    2273. 

  2273. #ifdef CHECKBUFSIZE
    2274. 

  2274.     size32_t v;
    2275. 

  2275.     if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&v, sizeof(v))!=0) {
    2276. 

  2276.         LOGERR2(ERRNO(),1,"getsockopt(SO_SNDBUF)");
    2277. 

  2277.     }
    2278. 

  2278.     if (v!=maxsend) 
    2279. 

  2279.         WARNLOG("set_send_buffer_size requested %d, got %d",maxsend,v);
    2280. 

  2280. #endif
    2281. 

  2281. }
    2282. 

  2282. 

  2283. 

  2284. size32_t CSocket::get_receive_buffer_size()
    2285. 

  2285. {
    2286. 

  2286.     size32_t max=0;
    2287. 

  2287.     socklen_t size = sizeof(max);
    2288. 

  2288.     getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *) &max, &size);  
    2289. 

  2289.     return max;
    2290. 

  2290. }
    2291. 

  2291. 

  2292. 

  2293. void CSocket::set_receive_buffer_size(size32_t max)
    2294. 

  2294. {
    2295. 

  2295.     if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&max, sizeof(max))!=0) {
    2296. 

  2296.         LOGERR2(ERRNO(),1,"setsockopt(SO_RCVBUF)");
    2297. 

  2297.     }
    2298. 

  2298. #ifdef CHECKBUFSIZE
    2299. 

  2299.     size32_t v;
    2300. 

  2300.     if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&v, sizeof(v))!=0) {
    2301. 

  2301.         LOGERR2(ERRNO(),1,"getsockopt(SO_RCVBUF)");
    2302. 

  2302.     }
    2303. 

  2303.     if (v<max) 
    2304. 

  2304.         WARNLOG("set_receive_buffer_size requested %d, got %d",max,v);
    2305. 

  2305. #endif
    2306. 

  2306. }
    2307. 

  2307. 

  2308. 

  2309. bool CSocket::join_multicast_group(SocketEndpoint &ep) 
    2310. 

  2310. {
    2311. 

  2311.     StringBuffer s;
    2312. 

  2312.     ep.getIpText(s);    // will improve later
    2313. 

  2313.     MCASTREQ req(s.str());
    2314. 

  2314.     if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,(char*)&req, sizeof(req))!=0) {
    2315. 

  2315.         return false;
    2316. 

  2316.     }
    2317. 

  2317.     return true;
    2318. 

  2318. }
    2319. 

  2319. 

  2320. 

  2321. bool CSocket::leave_multicast_group(SocketEndpoint &ep) 
    2322. 

  2322. {
    2323. 

  2323.     StringBuffer s;
    2324. 

  2324.     ep.getIpText(s);    // will improve later
    2325. 

  2325.     MCASTREQ req(s.str());
    2326. 

  2326.     if (setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,(char*)&req, sizeof(req))!=0) {
    2327. 

  2327.         return false;
    2328. 

  2328.     }
    2329. 

  2329.     return true;
    2330. 

  2330. }
    2331. 

  2331. 

  2332. 

  2333. 

  2334. CSocket::~CSocket()
    2335. 

  2335. {
    2336. 

  2336.   if (owned) 
    2337. 

  2337.     close();
    2338. 

  2338.   free(hostname);
    2339. 

  2339.   hostname = NULL;
    2340. 

  2340. #ifdef _TRACE
    2341. 

  2341.   free(tracename);
    2342. 

  2342.   tracename = NULL;
    2343. 

  2343. #endif
    2344. 

  2344.   delete mcastreq;
    2345. 

  2345. }
    2346. 

  2346. 

  2347. CSocket::CSocket(const SocketEndpoint &ep,SOCKETMODE smode,const char *name)
    2348. 

  2348. {
    2349. 

  2349.     state = ss_close;
    2350. 

  2350.     nonblocking = false;
    2351. 

  2351. #ifdef USERECVSEM
    2352. 

  2352.     receiveblocksemowned = false;
    2353. 

  2353. #endif
    2354. 

  2354.     nagling = true; // until turned off
    2355. 

  2355.     hostport = ep.port;
    2356. 

  2356.     hostname = NULL;
    2357. 

  2357.     mcastreq = NULL;
    2358. 

  2358.     tracename = NULL;
    2359. 

  2359.     StringBuffer tmp;
    2360. 

  2360.     if ((smode==sm_multicast_server)&&(name&&*name)) {
    2361. 

  2361.         mcastreq = new MCASTREQ(name);
    2362. 

  2362.     }
    2363. 

  2363.     else {
    2364. 

  2364.         if (!name&&!ep.isNull())
    2365. 

  2365.             name = ep.getIpText(tmp).str();
    2366. 

  2366.         hostname = name?strdup(name):NULL;
    2367. 

  2367.     }
    2368. 

  2368.     sock = INVALID_SOCKET;
    2369. 

  2369.     sockmode = smode;
    2370. 

  2370.     owned = true;
    2371. 

  2371.     nextblocksize = 0;
    2372. 

  2372.     in_accept = false;
    2373. 

  2373.     accept_cancel_state = accept_not_cancelled;
    2374. 

  2374. #ifdef _TRACE
    2375. 

  2375.     char peer[256];
    2376. 

  2376.     peer[0] = name?'T':'S';
    2377. 

  2377.     peer[1] = '>';
    2378. 

  2378.     if (name)
    2379. 

  2379.         strcpy(peer+2,name);
    2380. 

  2380.     else {
    2381. 

  2381.         SocketEndpoint self;
    2382. 

  2382.         self.setLocalHost(0);
    2383. 

  2383.         self.getUrlStr(peer+2,sizeof(peer)-2);
    2384. 

  2384.     }
    2385. 

  2385.     tracename = strdup(peer);
    2386. 

  2386. #endif
    2387. 

  2387. }
    2388. 

  2388. 

  2389. CSocket::CSocket(T_SOCKET new_sock,SOCKETMODE smode,bool _owned)
    2390. 

  2390. {
    2391. 

  2391.     nonblocking = false;
    2392. 

  2392. #ifdef USERECVSEM
    2393. 

  2393.     receiveblocksemowned = false;
    2394. 

  2394. #endif
    2395. 

  2395.     nagling = true; // until turned off
    2396. 

  2396.     sock = new_sock;
    2397. 

  2397.     if (new_sock!=INVALID_SOCKET)
    2398. 

  2398.         STATS.activesockets++;
    2399. 

  2399.     hostname = NULL;
    2400. 

  2400.     mcastreq = NULL;
    2401. 

  2401.     hostport = 0;
    2402. 

  2402.     tracename = NULL;
    2403. 

  2403.     state = ss_open;
    2404. 

  2404.     sockmode = smode;
    2405. 

  2405.     owned = _owned;
    2406. 

  2406.     nextblocksize = 0;
    2407. 

  2407.     in_accept = false;
    2408. 

  2408.     accept_cancel_state = accept_not_cancelled;
    2409. 

  2409.     set_nagle(false);
    2410. 

  2410.     //set_linger(DEFAULT_LINGER_TIME); -- experiment with removing this as closesocket should still endevour to send outstanding data
    2411. 

  2411. #ifdef _TRACE
    2412. 

  2412.     char peer[256];
    2413. 

  2413.     peer[0] = 'A';
    2414. 

  2414.     peer[1] = '!';
    2415. 

  2415.     peer_name(peer+2,sizeof(peer)-2);
    2416. 

  2416.     tracename = strdup(peer);
    2417. 

  2417. #endif
    2418. 

  2418. }
    2419. 

  2419. 

  2420. ISocket* ISocket::create(unsigned short p,int listen_queue_size)
    2421. 

  2421. {
    2422. 

  2422.     if (p==0)
    2423. 

  2423.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    2424. 

  2424.     SocketEndpoint ep;
    2425. 

  2425.     ep.port = p;
    2426. 

  2426.     Owned<CSocket> sock = new CSocket(ep,sm_tcp_server,NULL);
    2427. 

  2427.     sock->open(listen_queue_size);
    2428. 

  2428.     return sock.getClear();
    2429. 

  2429. }
    2430. 

  2430. 

  2431. 

  2432. ISocket* ISocket::create_ip(unsigned short p,const char *host,int listen_queue_size)
    2433. 

  2433. {
    2434. 

  2434.     if (p==0)
    2435. 

  2435.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    2436. 

  2436.     SocketEndpoint ep(host,p);
    2437. 

  2437.     Owned<CSocket> sock = new CSocket(ep,sm_tcp_server,host);
    2438. 

  2438.     sock->open(listen_queue_size);
    2439. 

  2439.     return sock.getClear();
    2440. 

  2440. }
    2441. 

  2441. 

  2442. 

  2443. ISocket* ISocket::udp_create(unsigned short p)
    2444. 

  2444. {
    2445. 

  2445.     SocketEndpoint ep;
    2446. 

  2446.     ep.port=p;
    2447. 

  2447.     Owned<CSocket> sock = new CSocket(ep,(p==0)?sm_udp:sm_udp_server,NULL);
    2448. 

  2448.     sock->open(0);
    2449. 

  2449.     return sock.getClear();
    2450. 

  2450. }
    2451. 

  2451. 

  2452. ISocket* ISocket::multicast_create(unsigned short p, const char *mcip)
    2453. 

  2453. {
    2454. 

  2454.     if (p==0)
    2455. 

  2455.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    2456. 

  2456.     SocketEndpoint ep(mcip,p);
    2457. 

  2457.     Owned<CSocket> sock = new CSocket(ep,sm_multicast_server,mcip);
    2458. 

  2458.     sock->open(0,true);
    2459. 

  2459.     return sock.getClear();
    2460. 

  2460. }
    2461. 

  2461. 

  2462. ISocket* ISocket::multicast_create(unsigned short p, const IpAddress &ip)
    2463. 

  2463. {
    2464. 

  2464.     if (p==0)
    2465. 

  2465.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    2466. 

  2466.     SocketEndpoint ep(p, ip);
    2467. 

  2467.     StringBuffer tmp;
    2468. 

  2468.     Owned<CSocket> sock = new CSocket(ep,sm_multicast_server,ip.getIpText(tmp).str());
    2469. 

  2469.     sock->open(0,true);
    2470. 

  2470.     return sock.getClear();
    2471. 

  2471. }
    2472. 

  2472. 

  2473. ISocket* ISocket::udp_connect(unsigned short p, char const* name)
    2474. 

  2474. {
    2475. 

  2475.     if (!name||!*name||(p==0))
    2476. 

  2476.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    2477. 

  2477.     SocketEndpoint ep(name, p);
    2478. 

  2478.     Owned<CSocket> sock = new CSocket(ep,sm_udp,name);
    2479. 

  2479.     sock->udpconnect();
    2480. 

  2480.     return sock.getClear();
    2481. 

  2481. }
    2482. 

  2482. 

  2483. ISocket* ISocket::udp_connect(const SocketEndpoint &ep)
    2484. 

  2484. {
    2485. 

  2485.     Owned<CSocket> sock = new CSocket(ep,sm_udp,NULL);
    2486. 

  2486.     sock->udpconnect();
    2487. 

  2487.     return sock.getClear();
    2488. 

  2488. }
    2489. 

  2489. 

  2490. ISocket* ISocket::multicast_connect(unsigned short p, char const* mcip, unsigned _ttl)
    2491. 

  2491. {
    2492. 

  2492.     if (p==0)
    2493. 

  2493.         THROWJSOCKEXCEPTION2(JSOCKERR_bad_address);
    2494. 

  2494.     SocketEndpoint ep(mcip,p);
    2495. 

  2495.     return multicast_connect(ep, _ttl);
    2496. 

  2496. }
    2497. 

  2497. 

  2498. ISocket* ISocket::multicast_connect(const SocketEndpoint &ep, unsigned _ttl)
    2499. 

  2499. {
    2500. 

  2500.     Owned<CSocket> sock = new CSocket(ep,sm_multicast,NULL);
    2501. 

  2501.     sock->udpconnect();
    2502. 

  2502.     u_char ttl = _ttl;
    2503. 

  2503.     setsockopt(sock->OShandle(), IPPROTO_IP, IP_MULTICAST_TTL, (char *) &ttl, sizeof(ttl));
    2504. 

  2504.     return sock.getClear();
    2505. 

  2505. }
    2506. 

  2506. 

  2507. ISocket* ISocket::attach(int s, bool tcpip)
    2508. 

  2508. {
    2509. 

  2509.     CSocket* sock = new CSocket((SOCKET)s, tcpip?sm_tcp:sm_udp, false);
    2510. 

  2510.     return sock;
    2511. 

  2511. }
    2512. 

  2512. 

  2513. bool isInterfaceIp(const IpAddress &ip, const char *ifname)
    2514. 

  2514. {
    2515. 

  2515. #ifdef _WIN32
    2516. 

  2516.     return false;
    2517. 

  2517. #else
    2518. 

  2518.     int fd = socket(AF_INET, SOCK_DGRAM, 0);  // IPV6 TBD
    2519. 

  2519.     if (fd<0)
    2520. 

  2520.         return false;
    2521. 

  2521.     MemoryAttr ma;
    2522. 

  2522.     char *buf = (char *)ma.allocate(1024); 
    2523. 

  2523.     struct ifconf ifc;
    2524. 

  2524.     ifc.ifc_len = 1024;
    2525. 

  2525.     ifc.ifc_buf = buf;
    2526. 

  2526.     if(ioctl(fd, SIOCGIFCONF, &ifc) < 0) // query interfaces
    2527. 

  2527.     {
    2528. 

  2528.         close(fd);
    2529. 

  2529.         return false;
    2530. 

  2530.     }
    2531. 

  2531.     struct ifreq *ifr = ifc.ifc_req;
    2532. 

  2532.     unsigned n = ifc.ifc_len/sizeof(struct ifreq);
    2533. 

  2533.     bool match = false;
    2534. 

  2534.     for(unsigned i=0; i<n; i++)
    2535. 

  2535.     {
    2536. 

  2536.         struct ifreq *item = &ifr[i];
    2537. 

  2537.         if (ifname&&*ifname)
    2538. 

  2538.             if (!WildMatch(item->ifr_name,ifname))
    2539. 

  2539.                 continue;
    2540. 

  2540.         IpAddress iptest((inet_ntoa(((struct sockaddr_in *)&item->ifr_addr)->sin_addr)));
    2541. 

  2541.         if (ip.ipequals(iptest))
    2542. 

  2542.         {
    2543. 

  2543.             match = true;
    2544. 

  2544.             break;
    2545. 

  2545.         }
    2546. 

  2546.     }
    2547. 

  2547.     close(fd);
    2548. 

  2548.     return match;
    2549. 

  2549. #endif
    2550. 

  2550. }
    2551. 

  2551. 

  2552. bool getInterfaceIp(IpAddress &ip,const char *ifname)
    2553. 

  2553. {
    2554. 

  2554. #ifdef _WIN32
    2555. 

  2555.     return false;
    2556. 

  2556. #else
    2557. 

  2557.     ip.ipset(NULL);
    2558. 

  2558.     int fd = socket(AF_INET, SOCK_DGRAM, 0);  // IPV6 TBD
    2559. 

  2559.     if (fd<0)
    2560. 

  2560.         return false;
    2561. 

  2561.     MemoryAttr ma;
    2562. 

  2562.     char *buf = (char *)ma.allocate(1024);
    2563. 

  2563.     struct ifconf ifc;
    2564. 

  2564.     ifc.ifc_len = 1024;
    2565. 

  2565.     ifc.ifc_buf = buf;
    2566. 

  2566.     if(ioctl(fd, SIOCGIFCONF, &ifc) < 0) // query interfaces
    2567. 

  2567.     {
    2568. 

  2568.         close(fd);
    2569. 

  2569.         return false;
    2570. 

  2570.     }
    2571. 

  2571.     struct ifreq *ifr = ifc.ifc_req;
    2572. 

  2572.     unsigned n = ifc.ifc_len/sizeof(struct ifreq);
    2573. 

  2573.     for (int loopback = 0; loopback <= 1; loopback++)
    2574. 

  2574.     {
    2575. 

  2575.         for (int i=0; i<n; i++)
    2576. 

  2576.         {
    2577. 

  2577.             bool useLoopback = (loopback==1);
    2578. 

  2578.             struct ifreq *item = &ifr[i];
    2579. 

  2579.             if (ifname&&*ifname)
    2580. 

  2580.                 if (!WildMatch(item->ifr_name,ifname))
    2581. 

  2581.                     continue;
    2582. 

  2582.             IpAddress iptest((inet_ntoa(((struct sockaddr_in *)&item->ifr_addr)->sin_addr)));
    2583. 

  2583.             if (iptest.isLoopBack() == useLoopback)
    2584. 

  2584.             {
    2585. 

  2585.                 if (ip.isNull())
    2586. 

  2586.                     ip.ipset(iptest);
    2587. 

  2587.                 else if (!PreferredSubnet.isNull()&&!PreferredSubnet.test(ip)&&PreferredSubnet.test(iptest))
    2588. 

  2588.                     ip.ipset(iptest);
    2589. 

  2589.             }
    2590. 

  2590.         }
    2591. 

  2591.         if (!ip.isNull())
    2592. 

  2592.             break;
    2593. 

  2593.     }
    2594. 

  2594.     close(fd);
    2595. 

  2595.     return !ip.isNull();
    2596. 

  2596. #endif
    2597. 

  2597. }
    2598. 

  2598. 

  2599. 

  2600. static StringAttr cachehostname;
    2601. 

  2601. static IpAddress cachehostip;
    2602. 

  2602. static IpAddress localhostip;
    2603. 

  2603. static CriticalSection hostnamesect;
    2604. 

  2604. static StringBuffer EnvConfPath;
    2605. 

  2605. 

  2606. const char * GetCachedHostName()
    2607. 

  2607. {
    2608. 

  2608.     CriticalBlock c(hostnamesect);
    2609. 

  2609.     if (!cachehostname.get())
    2610. 

  2610.     {
    2611. 

  2611. #ifndef _WIN32
    2612. 

  2612.         IpAddress ip;
    2613. 

  2613.         if (EnvConfPath.length() == 0)
    2614. 

  2614.             EnvConfPath.append(CONFIG_DIR).append(PATHSEPSTR).append("environment.conf");
    2615. 

  2615.         Owned<IProperties> conf = createProperties(EnvConfPath.str(), true);
    2616. 

  2616. 

  2617.         StringBuffer ifs;
    2618. 

  2618.         conf->getProp("interface", ifs);
    2619. 

  2619.         if (getInterfaceIp(ip, ifs.str()))
    2620. 

  2620.         {
    2621. 

  2621.             StringBuffer ips;
    2622. 

  2622.             ip.getIpText(ips);
    2623. 

  2623.             if (ips.length())
    2624. 

  2624.             {
    2625. 

  2625.                 cachehostname.set(ips.str());
    2626. 

  2626.                 cachehostip.ipset(ip);
    2627. 

  2627.                 return cachehostname.get();
    2628. 

  2628.             }
    2629. 

  2629.         }
    2630. 

  2630. #endif
    2631. 

  2631.         char temp[1024];
    2632. 

  2632.         if (gethostname(temp, sizeof(temp))==0)
    2633. 

  2633.             cachehostname.set(temp);                
    2634. 

  2634.         else
    2635. 

  2635.             cachehostname.set("localhost");         // assume no NIC card
    2636. 

  2636.     }
    2637. 

  2637.     return cachehostname.get();
    2638. 

  2638. }
    2639. 

  2639. 

  2640. 

  2641. IpAddress & queryLocalIP()
    2642. 

  2642. {
    2643. 

  2643.     CriticalBlock c(hostnamesect);
    2644. 

  2644.     if (localhostip.isNull()) 
    2645. 

  2645.         if (IP6preferred)
    2646. 

  2646.             localhostip.ipset("::1");   //IPv6 
    2647. 

  2647.         else
    2648. 

  2648.             localhostip.ipset("127.0.0.1"); //IPv4
    2649. 

  2649.     return localhostip;
    2650. 

  2650. }
    2651. 

  2651. 

  2652. IpAddress & queryHostIP()
    2653. 

  2653. {
    2654. 

  2654.     CriticalBlock c(hostnamesect);
    2655. 

  2655.     if (cachehostip.isNull()) {
    2656. 

  2656.         if (!cachehostip.ipset(GetCachedHostName())) {
    2657. 

  2657.             cachehostip.ipset(queryLocalIP());          
    2658. 

  2658.             printf("hostname %s not resolved, using localhost\n",GetCachedHostName()); // don't use jlog in case recursive
    2659. 

  2659.         }
    2660. 

  2660.     }
    2661. 

  2661.     return cachehostip;
    2662. 

  2662. }
    2663. 

  2663. 

  2664. IpAddress &GetHostIp(IpAddress &ip)
    2665. 

  2665. {
    2666. 

  2666.     ip.ipset(queryHostIP());
    2667. 

  2667.     return ip;
    2668. 

  2668. }
    2669. 

  2669. 

  2670. IpAddress &localHostToNIC(IpAddress &ip)
    2671. 

  2671. {
    2672. 

  2672.     if (ip.isLoopBack())
    2673. 

  2673.         GetHostIp(ip);
    2674. 

  2674.     return ip;
    2675. 

  2675. }
    2676. 

  2676. 

  2677. // IpAddress
    2678. 

  2678. 

  2679. 

  2680. inline bool isIp4(const unsigned *netaddr)
    2681. 

  2681. {
    2682. 

  2682.     if (IP4only)
    2683. 

  2683.         return true;
    2684. 

  2684.     if (netaddr[2]==0xffff0000)
    2685. 

  2685.         return (netaddr[1]==0)&&(netaddr[0]==0);
    2686. 

  2686.     if (netaddr[2]==0)
    2687. 

  2687.         if ((netaddr[3]==0)&&(netaddr[0]==0)&&(netaddr[1]==0))
    2688. 

  2688.             return true; // null address
    2689. 

  2689.     // maybe should get loopback here
    2690. 

  2690.     return false;
    2691. 

  2691. }
    2692. 

  2692. 

  2693. bool IpAddress::isIp4() const
    2694. 

  2694. {
    2695. 

  2695.     return ::isIp4(netaddr);
    2696. 

  2696. }
    2697. 

  2697. 

  2698. bool IpAddress::isNull() const
    2699. 

  2699. {
    2700. 

  2700.     return (netaddr[3]==0)&&(IP4only||((netaddr[2]==0)&&(netaddr[1]==0)&&(netaddr[0]==0)));
    2701. 

  2701. }
    2702. 

  2702. 

  2703. bool IpAddress::isLoopBack() const
    2704. 

  2704. {
    2705. 

  2705.     if (::isIp4(netaddr)&&((netaddr[3] & 0x000000ff)==0x000007f))
    2706. 

  2706.         return true;
    2707. 

  2707.     return (netaddr[3]==0x1000000)&&(netaddr[2]==0)&&(netaddr[1]==0)&&(netaddr[0]==0);
    2708. 

  2708. }
    2709. 

  2709. 

  2710. bool IpAddress::isLocal() const 
    2711. 

  2711. { 
    2712. 

  2712.     if (isLoopBack() || isHost())
    2713. 

  2713.         return true;
    2714. 

  2714.     IpAddress ip(*this);
    2715. 

  2715.     return isInterfaceIp(ip, NULL);
    2716. 

  2716. }
    2717. 

  2717. 

  2718. bool IpAddress::ipequals(const IpAddress & other) const
    2719. 

  2719. {
    2720. 

  2720.     // reverse compare for speed
    2721. 

  2721.     return (other.netaddr[3]==netaddr[3])&&(IP4only||((other.netaddr[2]==netaddr[2])&&(other.netaddr[1]==netaddr[1])&&(other.netaddr[0]==netaddr[0])));
    2722. 

  2722. }
    2723. 

  2723. 

  2724. int  IpAddress::ipcompare(const IpAddress & other) const
    2725. 

  2725. {
    2726. 

  2726.     return memcmp(&netaddr, &other.netaddr, sizeof(netaddr));
    2727. 

  2727. }
    2728. 

  2728. 

  2729. unsigned IpAddress::iphash(unsigned prev) const
    2730. 

  2730. {
    2731. 

  2731.     return hashc((const byte *)&netaddr,sizeof(netaddr),prev);
    2732. 

  2732. }
    2733. 

  2733. 

  2734. bool IpAddress::isHost() const
    2735. 

  2735. {
    2736. 

  2736.     return ipequals(queryHostIP());
    2737. 

  2737. }
    2738. 

  2738. 

  2739. static bool decodeNumericIP(const char *text,unsigned *netaddr)
    2740. 

  2740. {
    2741. 

  2741.     if (!text)
    2742. 

  2742.         return false;
    2743. 

  2743.     bool isv6 = strchr(text,':')!=NULL;
    2744. 

  2744.     StringBuffer tmp;
    2745. 

  2745.     if ((*text=='[')&&!IP4only) {
    2746. 

  2746.         text++;
    2747. 

  2747.         size32_t l = strlen(text);
    2748. 

  2748.         if ((l<=2)||(text[l-1]!=']'))
    2749. 

  2749.             return false;
    2750. 

  2750.         text = tmp.append(l-2,text);
    2751. 

  2751.     }
    2752. 

  2752.     if (!isv6&&isdigit(text[0])) {
    2753. 

  2753.         if (_inet_pton(AF_INET, text, &netaddr[3])>0) {
    2754. 

  2754.             netaddr[2] = netaddr[3]?0xffff0000:0;  // check for NULL
    2755. 

  2755.             netaddr[1] = 0;
    2756. 

  2756.             netaddr[0] = 0;         // special handling for loopback?
    2757. 

  2757.             return true;
    2758. 

  2758.         }
    2759. 

  2759.     }
    2760. 

  2760.     else if (isv6&&!IP4only) {
    2761. 

  2761.         int ret = _inet_pton(AF_INET6, text, netaddr);
    2762. 

  2762.         if (ret>=0)
    2763. 

  2763.             return (ret>0);
    2764. 

  2764.         int err = ERRNO();
    2765. 

  2765.         StringBuffer tmp("_inet_pton: ");
    2766. 

  2766.         tmp.append(text);
    2767. 

  2767.         LOGERR(err,1,tmp.str());
    2768. 

  2768.     }   
    2769. 

  2769.     return false;
    2770. 

  2770. }
    2771. 

  2771. 

  2772. static bool lookupHostAddress(const char *name,unsigned *netaddr)
    2773. 

  2773. {
    2774. 

  2774.     // if IP4only or using MS V6 can only resolve IPv4 using 
    2775. 

  2775.     static bool recursioncheck = false; // needed to stop error message recursing
    2776. 

  2776.     unsigned retry=10;
    2777. 

  2777. #if defined(__linux__) || defined(getaddrinfo)
    2778. 

  2778.     if (IP4only) {
    2779. 

  2779. #else
    2780. 

  2780.     {
    2781. 

  2781. #endif
    2782. 

  2782.         CriticalBlock c(hostnamesect);
    2783. 

  2783.         hostent * entry = gethostbyname(name);
    2784. 

  2784.         while (entry==NULL) {
    2785. 

  2785.             if (retry--==0) {
    2786. 

  2786.                 if (!recursioncheck) {
    2787. 

  2787.                     recursioncheck = true;
    2788. 

  2788.                     LogErr(h_errno,1,"gethostbyname failed",__LINE__,name);
    2789. 

  2789.                     recursioncheck = false;
    2790. 

  2790.                 }
    2791. 

  2791.                 return false;
    2792. 

  2792.             }
    2793. 

  2793.             {
    2794. 

  2794.                 CriticalUnblock ub(hostnamesect);
    2795. 

  2795.                 Sleep((10-retry)*100);
    2796. 

  2796.             }
    2797. 

  2797.             entry = gethostbyname(name);
    2798. 

  2798.         }
    2799. 

  2799.         if (entry->h_addr_list[0]) {
    2800. 

  2800.             unsigned ptr = 0;
    2801. 

  2801.             if (!PreferredSubnet.isNull()) {
    2802. 

  2802.                 loop {
    2803. 

  2803.                     ptr++;
    2804. 

  2804.                     if (entry->h_addr_list[ptr]==NULL) {
    2805. 

  2805.                         ptr = 0;
    2806. 

  2806.                         break;
    2807. 

  2807.                     }
    2808. 

  2808.                     IpAddress ip;
    2809. 

  2809.                     ip.setNetAddress(sizeof(unsigned),entry->h_addr_list[ptr]);
    2810. 

  2810.                     if (PreferredSubnet.test(ip))
    2811. 

  2811.                         break;
    2812. 

  2812.                 }
    2813. 

  2813.             }
    2814. 

  2814.             memcpy(&netaddr[3], entry->h_addr_list[ptr], sizeof(netaddr[3]));
    2815. 

  2815.             netaddr[2] = 0xffff0000;
    2816. 

  2816.             netaddr[1] = 0;
    2817. 

  2817.             netaddr[0] = 0;
    2818. 

  2818.             return true;
    2819. 

  2819.         }
    2820. 

  2820.         return false;
    2821. 

  2821.     }
    2822. 

  2822. #if defined(__linux__) || defined(getaddrinfo)
    2823. 

  2823.     struct addrinfo hints;
    2824. 

  2824.     memset(&hints,0,sizeof(hints));
    2825. 

  2825.     struct addrinfo  *addrInfo = NULL;
    2826. 

  2826.     loop {
    2827. 

  2827.         memset(&hints,0,sizeof(hints));
    2828. 

  2828.         int ret = getaddrinfo(name, NULL , &hints, &addrInfo);
    2829. 

  2829.         if (!ret) 
    2830. 

  2830.             break;
    2831. 

  2831.         if (retry--==0) {
    2832. 

  2832.             if (!recursioncheck) {
    2833. 

  2833.                 recursioncheck = true;
    2834. 

  2834.                 LogErr(ret,1,"getaddrinfo failed",__LINE__,name);
    2835. 

  2835. #ifdef _DEBUG
    2836. 

  2836.                 PrintStackReport();
    2837. 

  2837. #endif
    2838. 

  2838.                 recursioncheck = false;
    2839. 

  2839.             }
    2840. 

  2840.             return false;
    2841. 

  2841.         }
    2842. 

  2842.         Sleep((10-retry)*100);
    2843. 

  2843.     }
    2844. 

  2844.     struct addrinfo  *best = NULL;
    2845. 

  2845.     bool snm = !PreferredSubnet.isNull();
    2846. 

  2846.     loop {
    2847. 

  2847.         struct addrinfo  *ai;
    2848. 

  2848.         for (ai = addrInfo; ai; ai = ai->ai_next) {
    2849. 

  2849. //          printf("flags=%d, family=%d, socktype=%d, protocol=%d, addrlen=%d, canonname=%s\n",ai->ai_flags,ai->ai_family,ai->ai_socktype,ai->ai_protocol,ai->ai_addrlen,ai->ai_canonname?ai->ai_canonname:"NULL");
    2850. 

  2850.             switch (ai->ai_family) {
    2851. 

  2851.             case AF_INET: {
    2852. 

  2852.                     if (snm) {
    2853. 

  2853.                         IpAddress ip;
    2854. 

  2854.                         ip.setNetAddress(sizeof(in_addr),&(((sockaddr_in *)ai->ai_addr)->sin_addr));
    2855. 

  2855.                         if (!PreferredSubnet.test(ip))
    2856. 

  2856.                             continue;
    2857. 

  2857.                     }
    2858. 

  2858.                     if ((best==NULL)||((best->ai_family==AF_INET6)&&!IP6preferred))
    2859. 

  2859.                         best = ai;
    2860. 

  2860.                     break;
    2861. 

  2861.                 }
    2862. 

  2862.             case AF_INET6: {
    2863. 

  2863.                     if (snm) {
    2864. 

  2864.                         IpAddress ip;
    2865. 

  2865.                         ip.setNetAddress(sizeof(in_addr6),&(((sockaddr_in6 *)ai->ai_addr)->sin6_addr));
    2866. 

  2866.                         if (!PreferredSubnet.test(ip))
    2867. 

  2867.                             continue;
    2868. 

  2868.                     }
    2869. 

  2869.                     if ((best==NULL)||((best->ai_family==AF_INET)&&IP6preferred))
    2870. 

  2870.                         best = ai;
    2871. 

  2871.                     break;
    2872. 

  2872.                 }                   
    2873. 

  2873.             }
    2874. 

  2874.         }
    2875. 

  2875.         if (best||!snm)
    2876. 

  2876.             break;
    2877. 

  2877.         snm = false;
    2878. 

  2878.     }
    2879. 

  2879.     if (best) {
    2880. 

  2880.         if (best->ai_family==AF_INET6)
    2881. 

  2881.             memcpy(netaddr,&(((sockaddr_in6 *)best->ai_addr)->sin6_addr),sizeof(in6_addr));
    2882. 

  2882.         else {
    2883. 

  2883.             memcpy(netaddr+3,&(((sockaddr_in *)best->ai_addr)->sin_addr),sizeof(in_addr));
    2884. 

  2884.             netaddr[2] = 0xffff0000;
    2885. 

  2885.             netaddr[1] = 0;
    2886. 

  2886.             netaddr[0] = 0;
    2887. 

  2887.         }
    2888. 

  2888.     }
    2889. 

  2889.     freeaddrinfo(addrInfo);
    2890. 

  2890.     return best!=NULL;
    2891. 

  2891. #endif
    2892. 

  2892.     return false;
    2893. 

  2893.             
    2894. 

  2894. }
    2895. 

  2895. 

  2896. 

  2897. 

  2898. bool IpAddress::ipset(const char *text)
    2899. 

  2899. {
    2900. 

  2900.     if (text&&*text) {
    2901. 

  2901.         if ((text[0]=='.')&&(text[1]==0)) {
    2902. 

  2902.             ipset(queryHostIP());
    2903. 

  2903.             return true;
    2904. 

  2904.         }
    2905. 

  2905.         if (decodeNumericIP(text,netaddr))
    2906. 

  2906.             return true;
    2907. 

  2907.         const char *s;
    2908. 

  2908.         for (s=text;*s;s++)
    2909. 

  2909.             if (!isdigit(*s)&&(*s!=':')&&(*s!='.')) 
    2910. 

  2910.                 break;
    2911. 

  2911.         if (!*s)
    2912. 

  2912.             return ipset(NULL);
    2913. 

  2913.         if (lookupHostAddress(text,netaddr))
    2914. 

  2914.             return true;
    2915. 

  2915.     }
    2916. 

  2916.     memset(&netaddr,0,sizeof(netaddr));
    2917. 

  2917.     return false;
    2918. 

  2918. }
    2919. 

  2919. 

  2920. inline char * addbyte(char *s,byte b)
    2921. 

  2921. {
    2922. 

  2922.     if (b>=100) {
    2923. 

  2923.         *(s++) = b/100+'0';
    2924. 

  2924.         b %= 100;
    2925. 

  2925.         *(s++) = b/10+'0';
    2926. 

  2926.         b %= 10;
    2927. 

  2927.     }
    2928. 

  2928.     else if (b>=10) {
    2929. 

  2929.         *(s++) = b/10+'0';
    2930. 

  2930.         b %= 10;
    2931. 

  2931.     }
    2932. 

  2932.     *(s++) = b+'0';
    2933. 

  2933.     return s;
    2934. 

  2934. }
    2935. 

  2935.         
    2936. 

  2936. 

  2937. 

  2938. StringBuffer & IpAddress::getIpText(StringBuffer & out) const
    2939. 

  2939. {
    2940. 

  2940.     if (::isIp4(netaddr)) {
    2941. 

  2941.         const byte *ip = (const byte *)&netaddr[3];
    2942. 

  2942.         char ips[16]; 
    2943. 

  2943.         char *s = ips;
    2944. 

  2944.         for (unsigned i=0;i<4;i++) {
    2945. 

  2945.             if (i)
    2946. 

  2946.                 *(s++) = '.';
    2947. 

  2947.             s = addbyte(s,ip[i]);
    2948. 

  2948.         }
    2949. 

  2949.         return out.append(s-ips,ips); 
    2950. 

  2950.     }
    2951. 

  2951.     char tmp[INET6_ADDRSTRLEN];
    2952. 

  2952.     const char *res = _inet_ntop(AF_INET6, &netaddr, tmp, sizeof(tmp));
    2953. 

  2953.     if (!res) 
    2954. 

  2954.         throw MakeOsException(errno);
    2955. 

  2955.     return out.append(res);
    2956. 

  2956. }
    2957. 

  2957. 

  2958. void IpAddress::ipserialize(MemoryBuffer & out) const
    2959. 

  2959. {
    2960. 

  2960.     if (((netaddr[2]==0xffff0000)||(netaddr[2]==0))&&(netaddr[1]==0)&&(netaddr[0]==0)) {
    2961. 

  2961.         if (netaddr[3]==IPV6_SERIALIZE_PREFIX)
    2962. 

  2962.             throw MakeStringException(-1,"Invalid network address"); // hack prevention
    2963. 

  2963.         out.append(sizeof(netaddr[3]), &netaddr[3]); 
    2964. 

  2964.     }
    2965. 

  2965.     else {
    2966. 

  2966.         unsigned pfx = IPV6_SERIALIZE_PREFIX;
    2967. 

  2967.         out.append(sizeof(pfx),&pfx).append(sizeof(netaddr),&netaddr);
    2968. 

  2968.     }
    2969. 

  2969. }
    2970. 

  2970. 

  2971. void IpAddress::ipdeserialize(MemoryBuffer & in)
    2972. 

  2972. {
    2973. 

  2973.     unsigned pfx;
    2974. 

  2974.     in.read(sizeof(pfx),&pfx);
    2975. 

  2975.     if (pfx!=IPV6_SERIALIZE_PREFIX) {
    2976. 

  2976.         netaddr[0] = 0;
    2977. 

  2977.         netaddr[1] = 0;
    2978. 

  2978.         netaddr[2] = (pfx == 0 || pfx == 0x1000000) ? 0 : 0xffff0000; // catch null and loopback
    2979. 

  2979.         netaddr[3] = pfx;
    2980. 

  2980.     }
    2981. 

  2981.     else 
    2982. 

  2982.         in.read(sizeof(netaddr),&netaddr);
    2983. 

  2983. }
    2984. 

  2984. 

  2985. 

  2986. unsigned IpAddress::ipdistance(const IpAddress &other,unsigned offset) const
    2987. 

  2987. {   
    2988. 

  2988.     if (offset>3)
    2989. 

  2989.         offset = 3;
    2990. 

  2990.     int i1;
    2991. 

  2991.     _cpyrev4(&i1,&netaddr[3-offset]);
    2992. 

  2992.     int i2;
    2993. 

  2993.     _cpyrev4(&i2,&other.netaddr[3-offset]);
    2994. 

  2994.     i1-=i2;
    2995. 

  2995.     if (i1>0)
    2996. 

  2996.         return i1;
    2997. 

  2997.     return -i1;
    2998. 

  2998. }
    2999. 

  2999. 

  3000. bool IpAddress::ipincrement(unsigned count,byte minoctet,byte maxoctet,unsigned short minipv6piece,unsigned maxipv6piece)
    3001. 

  3001. {
    3002. 

  3002.     unsigned base;
    3003. 

  3003.     if (::isIp4(netaddr)) {
    3004. 

  3004.         base = maxoctet-minoctet+1;
    3005. 

  3005.         if (!base||(base>256))
    3006. 

  3006.             return false;
    3007. 

  3007.         byte * ips = (byte *)&netaddr[3];
    3008. 

  3008.         byte * ip = ips+4;
    3009. 

  3009.         while (count) {
    3010. 

  3010.             if (ip==ips)
    3011. 

  3011.                 return false;   // overflow
    3012. 

  3012.             ip--;
    3013. 

  3013.             unsigned v = (count+((*ip>minoctet)?(*ip-minoctet):0));
    3014. 

  3014.             *ip = minoctet + v%base;
    3015. 

  3015.             count = v/base;
    3016. 

  3016.         }
    3017. 

  3017.     }
    3018. 

  3018.     else {
    3019. 

  3019.         base = maxipv6piece-minipv6piece+1;
    3020. 

  3020.         if (!base||(base>0x10000))
    3021. 

  3021.             return false;
    3022. 

  3022.         unsigned short * ps = (unsigned short *)&netaddr;
    3023. 

  3023.         unsigned short * p = ps+8;
    3024. 

  3024.         while (count) {
    3025. 

  3025.             if (p==ps)
    3026. 

  3026.                 return false;   // overflow (actually near impossible!)
    3027. 

  3027.             p--;
    3028. 

  3028.             unsigned v = (count+((*p>minipv6piece)?(*p-minipv6piece):0));
    3029. 

  3029.             *p = minipv6piece + v%base;
    3030. 

  3030.             count = v/base;
    3031. 

  3031.         }
    3032. 

  3032.     }
    3033. 

  3033.     return true;
    3034. 

  3034. }
    3035. 

  3035. 

  3036. unsigned IpAddress::ipsetrange( const char *text)  // e.g. 10.173.72.1-65  ('-' may be omitted)
    3037. 

  3037. {
    3038. 

  3038.     unsigned e=0;
    3039. 

  3039.     unsigned f=0;
    3040. 

  3040.     const char *r = strchr(text,'-');   
    3041. 

  3041.     bool ok;
    3042. 

  3042.     if (r) {
    3043. 

  3043.         e = atoi(r+1);
    3044. 

  3044.         StringBuffer tmp(r-text,text);
    3045. 

  3045.         ok = ipset(tmp.str());
    3046. 

  3046.         if (!::isIp4(netaddr))
    3047. 

  3047.             IPV6_NOT_IMPLEMENTED();              // TBD IPv6
    3048. 

  3048.         if (ok) {
    3049. 

  3049.             while ((r!=text)&&(*(r-1)!='.'))
    3050. 

  3050.                 r--;
    3051. 

  3051.             f = (r!=text)?atoi(r):0;    
    3052. 

  3052.         }
    3053. 

  3053.     }
    3054. 

  3054.     else
    3055. 

  3055.         ok = ipset(text);
    3056. 

  3056.     if ((f>e)||!ok) 
    3057. 

  3057.         return 0;
    3058. 

  3058.     return e-f+1;
    3059. 

  3059. }
    3060. 

  3060. 

  3061. 

  3062. size32_t IpAddress::getNetAddress(size32_t maxsz,void *dst) const
    3063. 

  3063. {
    3064. 

  3064.     if (maxsz==sizeof(unsigned)) {
    3065. 

  3065.         if (::isIp4(netaddr)) {
    3066. 

  3066.             *(unsigned *)dst = netaddr[3];
    3067. 

  3067.             return maxsz;
    3068. 

  3068.         }
    3069. 

  3069.     }
    3070. 

  3070.     else if (!IP4only&&(maxsz==sizeof(netaddr))) {
    3071. 

  3071.         memcpy(dst,&netaddr,maxsz);
    3072. 

  3072.         return maxsz;
    3073. 

  3073.     }
    3074. 

  3074.     return 0;
    3075. 

  3075. }
    3076. 

  3076. 

  3077. void IpAddress::setNetAddress(size32_t sz,const void *src)
    3078. 

  3078. {
    3079. 

  3079.     if (sz==sizeof(unsigned)) { // IPv4
    3080. 

  3080.         netaddr[0] = 0;
    3081. 

  3081.         netaddr[1] = 0;
    3082. 

  3082.         netaddr[3] = *(const unsigned *)src;
    3083. 

  3083.         netaddr[2] = netaddr[3] ? 0xffff0000 : 0; // leave as null if Ipv4 address is null
    3084. 

  3084.     }
    3085. 

  3085.     else if (!IP4only&&(sz==sizeof(netaddr))) { // IPv6
    3086. 

  3086.         memcpy(&netaddr,src,sz);
    3087. 

  3087.         if ((netaddr[2]==0)&&(netaddr[3]!=0)&&(netaddr[3]!=0x1000000)&&(netaddr[0]==0)&&(netaddr[1]==0))
    3088. 

  3088.             netaddr[2]=0xffff0000;  // use this form only
    3089. 

  3089.     }
    3090. 

  3090.     else
    3091. 

  3091.         memset(&netaddr,0,sizeof(netaddr));
    3092. 

  3092. }
    3093. 

  3093. 

  3094. 

  3095. void SocketEndpoint::deserialize(MemoryBuffer & in)
    3096. 

  3096. {
    3097. 

  3097.     ipdeserialize(in);
    3098. 

  3098.     in.read(port);
    3099. 

  3099. }
    3100. 

  3100. 

  3101. void SocketEndpoint::serialize(MemoryBuffer & out) const
    3102. 

  3102. {
    3103. 

  3103.     ipserialize(out);
    3104. 

  3104.     out.append(port);
    3105. 

  3105. }
    3106. 

  3106. 

  3107. 

  3108. bool SocketEndpoint::set(const char *name,unsigned short _port)
    3109. 

  3109. { 
    3110. 

  3110.     if (name) {
    3111. 

  3111.         if (*name=='[') { 
    3112. 

  3112.             const char *s = name+1;
    3113. 

  3113.             const char *t = strchr(s,']');
    3114. 

  3114.             if (t) {
    3115. 

  3115.                 StringBuffer tmp(t-s,s);
    3116. 

  3116.                 if (t[1]==':') 
    3117. 

  3117.                     _port = atoi(t+2);
    3118. 

  3118.                 return set(tmp.str(),_port);
    3119. 

  3119.             }
    3120. 

  3120.         }
    3121. 

  3121.         const char * colon = strchr(name, ':');
    3122. 

  3122.         if (colon) {
    3123. 

  3123.             if (!IP4only&&strchr(colon+1, ':'))
    3124. 

  3124.                 colon = NULL; // hello its IpV6
    3125. 

  3125.         }
    3126. 

  3126.         else
    3127. 

  3127.             colon = strchr(name, '|'); // strange hole convention
    3128. 

  3128.         char ips[260];
    3129. 

  3129.         if (colon) {
    3130. 

  3130.             size32_t l = colon-name;
    3131. 

  3131.             if (l>=sizeof(ips))
    3132. 

  3132.                 l = sizeof(ips)-1;
    3133. 

  3133.             memcpy(ips,name,l);
    3134. 

  3134.             ips[l] = 0;
    3135. 

  3135.             name = ips;
    3136. 

  3136.             _port = atoi(colon+1);
    3137. 

  3137.         }
    3138. 

  3138.         if (ipset(name)) {
    3139. 

  3139.             port = _port; 
    3140. 

  3140.             return true;
    3141. 

  3141.         }
    3142. 

  3142.     }
    3143. 

  3143.     ipset(NULL);
    3144. 

  3144.     port = 0;   
    3145. 

  3145.     return false;
    3146. 

  3146. }
    3147. 

  3147. 

  3148. void SocketEndpoint::getUrlStr(char * str, size32_t len) const
    3149. 

  3149. {
    3150. 

  3150.     if (len==0)
    3151. 

  3151.         return;
    3152. 

  3152.     StringBuffer _str;
    3153. 

  3153.     getUrlStr(_str);
    3154. 

  3154.     size32_t l = _str.length()+1;
    3155. 

  3155.     if (l>len)
    3156. 

  3156.     { 
    3157. 

  3157.         l = len-1;
    3158. 

  3158.         str[l] = 0;
    3159. 

  3159.     }
    3160. 

  3160.     memcpy(str,_str.toCharArray(),l);
    3161. 

  3161. }
    3162. 

  3162. 

  3163. StringBuffer &SocketEndpoint::getUrlStr(StringBuffer &str) const
    3164. 

  3164. {
    3165. 

  3165.     getIpText(str);
    3166. 

  3166.     if (port) 
    3167. 

  3167.         str.append(':').append((unsigned)port);         // TBD IPv6 put [] on
    3168. 

  3168.     return str;
    3169. 

  3169. }
    3170. 

  3170. 

  3171. 

  3172. unsigned SocketEndpoint::hash(unsigned prev) const
    3173. 

  3173. {
    3174. 

  3174.     return hashc((const byte *)&port,sizeof(port),iphash(prev));
    3175. 

  3175. }
    3176. 

  3176. 

  3177. 

  3178. 

  3179. 

  3180. //---------------------------------------------------------------------------
    3181. 

  3181. 

  3182. SocketListCreator::SocketListCreator()
    3183. 

  3183. {
    3184. 

  3184.     lastPort = 0;
    3185. 

  3185. }
    3186. 

  3186. 

  3187. void SocketListCreator::addSocket(const SocketEndpoint &ep)
    3188. 

  3188. {
    3189. 

  3189.     StringBuffer ipstr;
    3190. 

  3190.     ep.getIpText(ipstr);
    3191. 

  3191.     addSocket(ipstr.str(), ep.port);
    3192. 

  3192. }
    3193. 

  3193. 

  3194. void SocketListCreator::addSocket(const char * ip, unsigned port)
    3195. 

  3195. {
    3196. 

  3196.     if (fullText.length())
    3197. 

  3197.         fullText.append("|");
    3198. 

  3198. 

  3199.     const char * prev = lastIp;
    3200. 

  3200.     const char * startCopy = ip;
    3201. 

  3201.     if (prev)
    3202. 

  3202.     {
    3203. 

  3203.         if (strcmp(ip, prev) == 0)
    3204. 

  3204.         {
    3205. 

  3205.             fullText.append("=");
    3206. 

  3206.             startCopy = NULL;
    3207. 

  3207.         }
    3208. 

  3208.         else
    3209. 

  3209.         {
    3210. 

  3210.             const char * cur = ip;
    3211. 

  3211.             loop
    3212. 

  3212.             {
    3213. 

  3213.                 char n = *cur;
    3214. 

  3214.                 if (!n)
    3215. 

  3215.                     break;
    3216. 

  3216.                 if (n != *prev)
    3217. 

  3217.                     break;
    3218. 

  3218.                 cur++; 
    3219. 

  3219.                 prev++;
    3220. 

  3220.                 if (n == '.')
    3221. 

  3221.                     startCopy = cur;
    3222. 

  3222.             }
    3223. 

  3223.             if (startCopy != ip)
    3224. 

  3224.                 fullText.append("*");
    3225. 

  3225.         }
    3226. 

  3226.     }
    3227. 

  3227. 

  3228.     fullText.append(startCopy);
    3229. 

  3229.     if (lastPort != port)
    3230. 

  3230.         fullText.append(":").append(port);
    3231. 

  3231. 

  3232.     lastIp.set(ip);
    3233. 

  3233.     lastPort = port;
    3234. 

  3234. }
    3235. 

  3235. 

  3236. const char * SocketListCreator::getText()
    3237. 

  3237. {
    3238. 

  3238.     return fullText.str();
    3239. 

  3239. }
    3240. 

  3240. 

  3241. void SocketListCreator::addSockets(SocketEndpointArray &array)
    3242. 

  3242. {
    3243. 

  3243.     ForEachItemIn(i,array) {
    3244. 

  3244.         SocketEndpoint &sockep=array.item(i);
    3245. 

  3245.         StringBuffer ipstr;
    3246. 

  3246.         sockep.getIpText(ipstr);
    3247. 

  3247.         addSocket(ipstr.str(),sockep.port);
    3248. 

  3248.     }
    3249. 

  3249. }
    3250. 

  3250. 

  3251. 

  3252. //---------------------------------------------------------------------------
    3253. 

  3253. 

  3254. SocketListParser::SocketListParser(const char * text)
    3255. 

  3255. {
    3256. 

  3256.     fullText.set(text);
    3257. 

  3257.     cursor = NULL;
    3258. 

  3258.     lastPort = 0;
    3259. 

  3259. }
    3260. 

  3260. 

  3261. void SocketListParser::first(unsigned port)
    3262. 

  3262. {
    3263. 

  3263.     cursor = fullText;
    3264. 

  3264.     lastIp.set(NULL);
    3265. 

  3265.     lastPort = port;
    3266. 

  3266. }
    3267. 

  3267. 

  3268. bool SocketListParser::get(StringAttr & ip, unsigned & port, unsigned index, unsigned defport)
    3269. 

  3269. {
    3270. 

  3270.     first(defport);
    3271. 

  3271.     do
    3272. 

  3272.     {
    3273. 

  3273.         if (!next(ip, port))
    3274. 

  3274.             return false;
    3275. 

  3275.     } while (index--);
    3276. 

  3276.     return true;
    3277. 

  3277. }
    3278. 

  3278. 

  3279. bool SocketListParser::next(StringAttr & ip, unsigned & port)
    3280. 

  3280. {
    3281. 

  3281.     // IPV6TBD
    3282. 

  3282. 

  3283.     StringBuffer ipText;
    3284. 

  3284.     if (*cursor == 0)
    3285. 

  3285.         return false;
    3286. 

  3286.     if (*cursor == '=')
    3287. 

  3287.     {
    3288. 

  3288.         ipText.append(lastIp);
    3289. 

  3289.         cursor++;
    3290. 

  3290.     }
    3291. 

  3291.     else if (*cursor == '*')
    3292. 

  3292.     {
    3293. 

  3293.         cursor++;
    3294. 

  3294. 

  3295.         //count the number of dots in the tail
    3296. 

  3296.         const char * cur = cursor;
    3297. 

  3297.         unsigned count = 0;
    3298. 

  3298.         loop
    3299. 

  3299.         {
    3300. 

  3300.             char c = *cur++;
    3301. 

  3301.             switch (c)
    3302. 

  3302.             {
    3303. 

  3303.             case 0:
    3304. 

  3304.             case '|':
    3305. 

  3305.             case ',':
    3306. 

  3306.             case ':':
    3307. 

  3307.                 goto done;
    3308. 

  3308.             case '.':
    3309. 

  3309.                 ++count;
    3310. 

  3310.                 break;
    3311. 

  3311.             }
    3312. 

  3312.         }
    3313. 

  3313. done:
    3314. 

  3314.         //copy up to the appropriate dot from the previous ip.
    3315. 

  3315.         const unsigned dotCount = 3;        //more what about 6 digit ip's
    3316. 

  3316.         cur = lastIp;
    3317. 

  3317.         loop
    3318. 

  3318.         {
    3319. 

  3319.             char c = *cur++;
    3320. 

  3320.             switch (c)
    3321. 

  3321.             {
    3322. 

  3322.             case 0:
    3323. 

  3323.             case '|':
    3324. 

  3324.             case ',':
    3325. 

  3325.             case ':':
    3326. 

  3326.                 assertex(!"Should not get here!");
    3327. 

  3327.                 goto done2;
    3328. 

  3328.             case '.':
    3329. 

  3329.                 ipText.append(c);
    3330. 

  3330.                 if (++count == dotCount)
    3331. 

  3331.                     goto done2;
    3332. 

  3332.                 break;
    3333. 

  3333.             default:
    3334. 

  3334.                 ipText.append(c);
    3335. 

  3335.                 break;
    3336. 

  3336.             }
    3337. 

  3337.         }
    3338. 

  3338. done2:;
    3339. 

  3339.     }
    3340. 

  3340. 

  3341.     bool inPort = false;
    3342. 

  3342.     port = lastPort;
    3343. 

  3343.     loop
    3344. 

  3344.     {
    3345. 

  3345.         char c = *cursor++;
    3346. 

  3346.         switch (c)
    3347. 

  3347.         {
    3348. 

  3348.         case 0:
    3349. 

  3349.             cursor--;
    3350. 

  3350.             goto doneCopy;
    3351. 

  3351.         case '|':
    3352. 

  3352.         case ',':
    3353. 

  3353.             goto doneCopy;
    3354. 

  3354.         case ':':
    3355. 

  3355.             port = atoi(cursor);
    3356. 

  3356.             inPort = true;
    3357. 

  3357.             break;;
    3358. 

  3358.         default:
    3359. 

  3359.             if (!inPort)
    3360. 

  3360.                 ipText.append(c);
    3361. 

  3361.             break;
    3362. 

  3362.         }
    3363. 

  3363.     }
    3364. 

  3364. 

  3365. doneCopy:
    3366. 

  3366.     lastIp.set(ipText.str());
    3367. 

  3367.     ip.set(lastIp);
    3368. 

  3368.     lastPort = port;
    3369. 

  3369.     return true;
    3370. 

  3370. }
    3371. 

  3371. 

  3372. unsigned SocketListParser::getSockets(SocketEndpointArray &array,unsigned defport)
    3373. 

  3373. {
    3374. 

  3374.     first(defport);
    3375. 

  3375.     StringAttr ip;
    3376. 

  3376.     unsigned port;
    3377. 

  3377.     while (next(ip,port)) {
    3378. 

  3378.         SocketEndpoint ep(ip,port);
    3379. 

  3379.         array.append(ep);
    3380. 

  3380.     }
    3381. 

  3381.     return array.ordinality();
    3382. 

  3382. }
    3383. 

  3383. 

  3384. void getSocketStatistics(JSocketStatistics &stats)
    3385. 

  3385. {
    3386. 

  3386.     // should put in simple lock
    3387. 

  3387.     memcpy(&stats,&STATS,sizeof(stats));
    3388. 

  3388. }
    3389. 

  3389. 

  3390. void resetSocketStatistics()
    3391. 

  3391. {
    3392. 

  3392.     unsigned activesockets=STATS.activesockets;
    3393. 

  3393.     memset(&STATS,0,sizeof(STATS));
    3394. 

  3394.     STATS.activesockets = activesockets;
    3395. 

  3395. }
    3396. 

  3396. 

  3397. static StringBuffer &appendtime(StringBuffer &s,unsigned us)
    3398. 

  3398. {
    3399. 

  3399.     // attemp to get into more sensible units
    3400. 

  3400.     if (us>10000000)
    3401. 

  3401.         return s.append(us/1000000).append('s');
    3402. 

  3402.     if (us>10000)
    3403. 

  3403.         return s.append(us/1000).append("ms");
    3404. 

  3404.     return s.append(us).append("us");
    3405. 

  3405. }
    3406. 

  3406. 

  3407. 

  3408. StringBuffer &getSocketStatisticsString(JSocketStatistics &stats,StringBuffer &str)
    3409. 

  3409. {
    3410. 

  3410. 

  3411.     str.append("connects=").append(stats.connects).append('\n');
    3412. 

  3412.     appendtime(str.append("connecttime="),stats.connecttime).append('\n');
    3413. 

  3413.     str.append("failedconnects=").append(stats.failedconnects).append('\n');
    3414. 

  3414.     appendtime(str.append("failedconnecttime="),stats.failedconnecttime).append('\n');
    3415. 

  3415.     str.append("reads=").append(stats.reads).append('\n');
    3416. 

  3416.     appendtime(str.append("readtime="),stats.readtime).append('\n');
    3417. 

  3417.     str.append("readsize=").append(stats.readsize).append(" bytes\n");
    3418. 

  3418.     str.append("writes=").append(stats.writes).append('\n');
    3419. 

  3419.     appendtime(str.append("writetime="),stats.writetime).append('\n');
    3420. 

  3420.     str.append("writesize=").append(stats.writesize).append(" bytes").append('\n');
    3421. 

  3421.     str.append("activesockets=").append(stats.activesockets).append('\n');
    3422. 

  3422.     str.append("numblockrecvs=").append(stats.numblockrecvs).append('\n');
    3423. 

  3423.     str.append("numblocksends=").append(stats.numblocksends).append('\n');
    3424. 

  3424.     str.append("blockrecvsize=").append(stats.blockrecvsize).append('\n');
    3425. 

  3425.     str.append("blocksendsize=").append(stats.blocksendsize).append('\n');
    3426. 

  3426.     str.append("blockrecvtime=").append(stats.blockrecvtime).append('\n');
    3427. 

  3427.     str.append("blocksendtime=").append(stats.blocksendtime).append('\n');
    3428. 

  3428.     str.append("longestblocksend=").append(stats.longestblocksend).append('\n');
    3429. 

  3429.     str.append("longestblocksize=").append(stats.longestblocksize);
    3430. 

  3430.     return str;
    3431. 

  3431. }
    3432. 

  3432. 

  3433. // ===============================================================================
    3434. 

  3434. // select thread for handling multiple selects
    3435. 

  3435. 

  3436. struct SelectItem
    3437. 

  3437. {
    3438. 

  3438.     ISocket *sock;
    3439. 

  3439.     T_SOCKET handle;
    3440. 

  3440.     ISocketSelectNotify *nfy;
    3441. 

  3441.     byte mode;
    3442. 

  3442.     bool del;
    3443. 

  3443.     bool add_epoll;
    3444. 

  3444. };
    3445. 

  3445. 

  3446. inline SelectItem &Array__Member2Param(SelectItem &src)                 { return src; }
    3447. 

  3447. inline void Array__Assign(SelectItem & dest, SelectItem &src)           { dest=src; }
    3448. 

  3448. inline bool Array__Equal(SelectItem &m, SelectItem &p)                  { return m.sock==p.sock; }
    3449. 

  3449. inline void Array__Destroy(SelectItem &p)                               { }
    3450. 

  3450. class SelectItemArray : public ArrayOf<SelectItem, SelectItem &> { };
    3451. 

  3451. 

  3452. #define SELECT_TIMEOUT_SECS 1           // but it does (TBD)
    3453. 

  3453. 

  3454. 

  3455. #ifdef _WIN32
    3456. 

  3456. 

  3457. // fd_set utility functions
    3458. 

  3458. inline T_FD_SET *cpyfds(T_FD_SET &dst,const T_FD_SET &src)
    3459. 

  3459. {
    3460. 

  3460.     unsigned i = src.fd_count;
    3461. 

  3461.     dst.fd_count = i;
    3462. 

  3462.     while (i--)
    3463. 

  3463.         dst.fd_array[i] = src.fd_array[i]; // possibly better as memcpy
    3464. 

  3464.     return &dst;
    3465. 

  3465. }
    3466. 

  3466. 

  3467. inline bool findfds(T_FD_SET &s,T_SOCKET h,bool &c) 
    3468. 

  3468. {
    3469. 

  3469.     unsigned n = s.fd_count;
    3470. 

  3470.     unsigned i;
    3471. 

  3471.     for(i=0;i<n;i++) {
    3472. 

  3472.         if (s.fd_array[i] == h) {
    3473. 

  3473.             if (--n)
    3474. 

  3474.                 s.fd_array[i] = s.fd_array[n]; // remove item
    3475. 

  3475.             else
    3476. 

  3476.                 c = false;
    3477. 

  3477.             s.fd_count = n;
    3478. 

  3478.             return true;
    3479. 

  3479.         }
    3480. 

  3480.     }
    3481. 

  3481.     return false;
    3482. 

  3482. }
    3483. 

  3483. 

  3484. inline T_SOCKET popfds(T_FD_SET &s)
    3485. 

  3485. {
    3486. 

  3486.     unsigned n = s.fd_count;
    3487. 

  3487.     T_SOCKET ret;
    3488. 

  3488.     if (n) {
    3489. 

  3489.         ret = s.fd_array[--n];
    3490. 

  3490.         s.fd_count = n;
    3491. 

  3491.     }
    3492. 

  3492.     else 
    3493. 

  3493.         ret = NULL;
    3494. 

  3494.     return ret;
    3495. 

  3495. }
    3496. 

  3496. 

  3497. #else
    3498. 

  3498. #define _USE_PIPE_FOR_SELECT_TRIGGER
    3499. 

  3499. 

  3500. 

  3501. // not as optimized as windows but I am expecting to convert to using poll anyway
    3502. 

  3502. inline T_FD_SET *cpyfds(T_FD_SET &dst,const T_FD_SET &src)
    3503. 

  3503. {
    3504. 

  3504.     memcpy(&dst,&src,sizeof(T_FD_SET));
    3505. 

  3505.     return &dst;
    3506. 

  3506. }
    3507. 

  3507. 

  3508. inline bool findfds(T_FD_SET &s,T_SOCKET h,bool &c) 
    3509. 

  3509. {
    3510. 

  3510.     if ((unsigned)h>=XFD_SETSIZE)
    3511. 

  3511.         return false;
    3512. 

  3512.     return FD_ISSET(h,&s); // does not remove entry or set termination flag when done
    3513. 

  3513. }
    3514. 

  3514. #endif
    3515. 

  3515. 

  3516. class CSocketBaseThread: public Thread
    3517. 

  3517. {
    3518. 

  3518. protected:
    3519. 

  3519.     bool terminating;
    3520. 

  3520.     CriticalSection sect;
    3521. 

  3521.     Semaphore ticksem;
    3522. 

  3522.     atomic_t tickwait;
    3523. 

  3523.     SelectItemArray items;
    3524. 

  3524.     unsigned offset;
    3525. 

  3525.     bool selectvarschange;
    3526. 

  3526.     unsigned waitingchange;
    3527. 

  3527.     Semaphore waitingchangesem;
    3528. 

  3528.     int validateselecterror;
    3529. 

  3529.     unsigned validateerrcount;
    3530. 

  3530.     const char *selecttrace;
    3531. 

  3531.     unsigned basesize;
    3532. 

  3532. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3533. 

  3533.     T_SOCKET dummysock[2];
    3534. 

  3534. #else
    3535. 

  3535.     T_SOCKET dummysock; 
    3536. 

  3536. #endif
    3537. 

  3537.     bool dummysockopen;
    3538. 

  3538. 

  3539.     CSocketBaseThread(const char *trc) : Thread("CSocketBaseThread")
    3540. 

  3540.     {
    3541. 

  3541.     }
    3542. 

  3542. 

  3543.     ~CSocketBaseThread()
    3544. 

  3544.     {
    3545. 

  3545.     }
    3546. 

  3546. 

  3547. public:
    3548. 

  3548.     void triggerselect()
    3549. 

  3549.     {
    3550. 

  3550.         if (atomic_read(&tickwait))
    3551. 

  3551.             ticksem.signal();
    3552. 

  3552. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3553. 

  3553.         CriticalBlock block(sect);
    3554. 

  3554.         char c = 0;
    3555. 

  3555.         if(write(dummysock[1], &c, 1) != 1) {
    3556. 

  3556.             int err = ERRNO();
    3557. 

  3557.             LOGERR(err,1,"Socket closed during trigger select");
    3558. 

  3558.         }
    3559. 

  3559. #else
    3560. 

  3560.         closedummy();
    3561. 

  3561. #endif
    3562. 

  3562.     }
    3563. 

  3563. 

  3564.     void resettrigger()
    3565. 

  3565.     {
    3566. 

  3566. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3567. 

  3567.         CriticalBlock block(sect);
    3568. 

  3568.         char c;
    3569. 

  3569.         while((::read(dummysock[0], &c, sizeof(c))) == sizeof(c));
    3570. 

  3570. #endif
    3571. 

  3571.     }
    3572. 

  3572. 

  3573.     bool remove(ISocket *sock)
    3574. 

  3574.     {
    3575. 

  3575.         if (terminating)
    3576. 

  3576.             return false;
    3577. 

  3577.         CriticalBlock block(sect);
    3578. 

  3578.         if (sock==NULL) { // wait until no changes outstanding
    3579. 

  3579.             while (selectvarschange) {
    3580. 

  3580.                 waitingchange++;
    3581. 

  3581.                 CriticalUnblock unblock(sect);
    3582. 

  3582.                 waitingchangesem.wait();
    3583. 

  3583.             }
    3584. 

  3584.             return true;
    3585. 

  3585.         }
    3586. 

  3586.         ForEachItemIn(i,items) {
    3587. 

  3587.             SelectItem &si = items.item(i);
    3588. 

  3588.             if (!si.del&&(si.sock==sock)) {
    3589. 

  3589.                 si.del = true;
    3590. 

  3590.                 selectvarschange = true;
    3591. 

  3591.                 triggerselect();
    3592. 

  3592.                 return true;
    3593. 

  3593.             }
    3594. 

  3594.         }
    3595. 

  3595.         return false;
    3596. 

  3596.     }
    3597. 

  3597. 

  3598.     void stop(bool wait)
    3599. 

  3599.     {
    3600. 

  3600.         terminating = true;
    3601. 

  3601.         triggerselect();
    3602. 

  3602.         if (wait)
    3603. 

  3603.             join();
    3604. 

  3604.     }
    3605. 

  3605. 

  3606. 

  3607.     bool sockOk(T_SOCKET sock)
    3608. 

  3608.     {
    3609. 

  3609.         PROGLOG("CSocketBaseThread: sockOk testing %d",sock);
    3610. 

  3610.         int err = 0;
    3611. 

  3611.         int t=0;
    3612. 

  3612.         socklen_t tl = sizeof(t);
    3613. 

  3613.         if (getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&t, &tl)!=0) {
    3614. 

  3614.             StringBuffer sockstr;
    3615. 

  3615.             const char *tracename = sockstr.append((unsigned)sock).str();
    3616. 

  3616.             LOGERR2(ERRNO(),1,"CSocketBaseThread select handle");
    3617. 

  3617.             return false;
    3618. 

  3618.         }
    3619. 

  3619.         T_FD_SET fds;
    3620. 

  3620.         struct timeval tv;
    3621. 

  3621.         XFD_ZERO(&fds);
    3622. 

  3622.         FD_SET((unsigned)sock, &fds);
    3623. 

  3623.         //FD_SET((unsigned)sock, &except);
    3624. 

  3624.         tv.tv_sec = 0;
    3625. 

  3625.         tv.tv_usec = 0;
    3626. 

  3626.         CHECKSOCKRANGE(sock);
    3627. 

  3627.         int rc = ::select( sock + 1, NULL, (fd_set *)&fds, NULL, &tv );
    3628. 

  3628.         if (rc<0) {
    3629. 

  3629.             StringBuffer sockstr;
    3630. 

  3630.             const char *tracename = sockstr.append((unsigned)sock).str();
    3631. 

  3631.             LOGERR2(ERRNO(),2,"CSocketBaseThread select handle");
    3632. 

  3632.             return false;
    3633. 

  3633.         }
    3634. 

  3634.         else if (rc>0)
    3635. 

  3635.             PROGLOG("CSocketBaseThread: select handle %d selected(2) %d",sock,rc);
    3636. 

  3636.         XFD_ZERO(&fds);
    3637. 

  3637.         FD_SET((unsigned)sock, &fds);
    3638. 

  3638.         tv.tv_sec = 0;
    3639. 

  3639.         tv.tv_usec = 0;
    3640. 

  3640.         rc = ::select( sock + 1, (fd_set *)&fds, NULL, NULL, &tv );
    3641. 

  3641.         if (rc<0) {
    3642. 

  3642.             StringBuffer sockstr;
    3643. 

  3643.             const char *tracename = sockstr.append((unsigned)sock).str();
    3644. 

  3644.             LOGERR2(ERRNO(),3,"CSocketBaseThread select handle");
    3645. 

  3645.             return false;
    3646. 

  3646.         }
    3647. 

  3647.         else if (rc>0)
    3648. 

  3648.             PROGLOG("CSocketBaseThread: select handle %d selected(2) %d",sock,rc);
    3649. 

  3649.         return true;
    3650. 

  3650.     }
    3651. 

  3651. 

  3652.     bool checkSocks()
    3653. 

  3653.     {
    3654. 

  3654.         bool ret = false;
    3655. 

  3655.         ForEachItemIn(i,items) {
    3656. 

  3656.             SelectItem &si = items.item(i);
    3657. 

  3657.             if (si.del)
    3658. 

  3658.                 ret = true; // maybe that bad one
    3659. 

  3659.             else  if (!sockOk(si.handle)) {
    3660. 

  3660.                 si.del = true;
    3661. 

  3661.                 ret = true;
    3662. 

  3662.             }
    3663. 

  3663.         }
    3664. 

  3664.         return ret;
    3665. 

  3665.     }
    3666. 

  3666. 

  3667.     virtual void closedummy() = 0;
    3668. 

  3668. };
    3669. 

  3669. 

  3670. class CSocketSelectThread: public CSocketBaseThread
    3671. 

  3671. {
    3672. 

  3672.     void opendummy()
    3673. 

  3673.     {
    3674. 

  3674.         CriticalBlock block(sect);
    3675. 

  3675.         if (!dummysockopen) { 
    3676. 

  3676. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3677. 

  3677.             if(pipe(dummysock)) {
    3678. 

  3678.                 WARNLOG("CSocketSelectThread: create pipe failed %d",ERRNO());
    3679. 

  3679.                 return;
    3680. 

  3680.             }
    3681. 

  3681.             for (unsigned i=0;i<2;i++) {
    3682. 

  3682.                 int flags = fcntl(dummysock[i], F_GETFL, 0);
    3683. 

  3683.                 if (flags!=-1) {
    3684. 

  3684.                     flags |= O_NONBLOCK;
    3685. 

  3685.                     fcntl(dummysock[i], F_SETFL, flags);
    3686. 

  3686.                 }
    3687. 

  3687.                 flags = fcntl(dummysock[i], F_GETFD, 0);
    3688. 

  3688.                 if (flags!=-1) {
    3689. 

  3689.                     flags |=  FD_CLOEXEC;
    3690. 

  3690.                     fcntl(dummysock[i], F_SETFD, flags);
    3691. 

  3691.                 }
    3692. 

  3692.             }
    3693. 

  3693.             CHECKSOCKRANGE(dummysock[0]);
    3694. 

  3694. #else
    3695. 

  3695.             if (IP6preferred)
    3696. 

  3696.                 dummysock = ::socket(AF_INET6, SOCK_STREAM, PF_INET6);
    3697. 

  3697.             else
    3698. 

  3698.                 dummysock = ::socket(AF_INET, SOCK_STREAM, 0);
    3699. 

  3699.             CHECKSOCKRANGE(dummysock);
    3700. 

  3700. #endif
    3701. 

  3701.             dummysockopen = true;
    3702. 

  3702.         }
    3703. 

  3703. 

  3704. 

  3705.     }
    3706. 

  3706. 

  3707.     void closedummy()
    3708. 

  3708.     {
    3709. 

  3709.         CriticalBlock block(sect);
    3710. 

  3710.         if (dummysockopen) { 
    3711. 

  3711. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3712. 

  3712. #ifdef SOCKTRACE
    3713. 

  3713.             PROGLOG("SOCKTRACE: Closing dummy sockets %x %d %x %d (%x)", dummysock[0], dummysock[0], dummysock[1], dummysock[1], this);
    3714. 

  3714. #endif
    3715. 

  3715.             ::close(dummysock[0]);
    3716. 

  3716.             ::close(dummysock[1]);
    3717. 

  3717. #else
    3718. 

  3718. #ifdef _WIN32
    3719. 

  3719.             ::closesocket(dummysock);
    3720. 

  3720. #else
    3721. 

  3721.             ::close(dummysock);
    3722. 

  3722. #endif
    3723. 

  3723. #endif
    3724. 

  3724.             dummysockopen = false;
    3725. 

  3725.         }
    3726. 

  3726.     }
    3727. 

  3727. 

  3728. 

  3729. #ifdef _WIN32
    3730. 

  3730. #define HASHTABSIZE 256
    3731. 

  3731. #define HASHNULL (HASHTABSIZE-1)
    3732. 

  3732. #define HASHTABMASK (HASHTABSIZE-1)
    3733. 

  3733.     byte hashtab[HASHTABSIZE];
    3734. 

  3734. #define HASHSOCKET(s) ((((unsigned)s)>>2)&HASHTABMASK)      // with some knowledge of windows handles
    3735. 

  3735. 

  3736.     void inithash()
    3737. 

  3737.     {
    3738. 

  3738.         memset(&hashtab,HASHNULL,sizeof(hashtab));
    3739. 

  3739.         assertex(FD_SETSIZE<255);
    3740. 

  3740.     }
    3741. 

  3741. 

  3742.     void reinithash()
    3743. 

  3743.     { // done this way because index of items changes and hash table not that big
    3744. 

  3744.         inithash();
    3745. 

  3745.         assertex(items.ordinality()<HASHTABSIZE-1);
    3746. 

  3746.         ForEachItemIn(i,items) {
    3747. 

  3747.             unsigned h = HASHSOCKET(items.item(i).handle);
    3748. 

  3748.             loop {
    3749. 

  3749.                 if (hashtab[h]==HASHNULL) {
    3750. 

  3750.                     hashtab[h] = (byte)i;
    3751. 

  3751.                     break;
    3752. 

  3752.                 }
    3753. 

  3753.                 if (++h==HASHTABSIZE)
    3754. 

  3754.                     h = 0;
    3755. 

  3755.             }
    3756. 

  3756.         }
    3757. 

  3757.     }
    3758. 

  3758. 

  3759.     inline SelectItem &findhash(T_SOCKET handle)
    3760. 

  3760.     {
    3761. 

  3761.         unsigned h = HASHSOCKET(handle);
    3762. 

  3762.         unsigned sh = h;
    3763. 

  3763.         loop {
    3764. 

  3764.             SelectItem &i=items.item(hashtab[h]);
    3765. 

  3765.             if (i.handle==handle) 
    3766. 

  3766.                 return i;
    3767. 

  3767.             if (++h==HASHTABSIZE)
    3768. 

  3768.                 h = 0;
    3769. 

  3769.             assertex(h!=sh);
    3770. 

  3770.         }
    3771. 

  3771.     }
    3772. 

  3772. 

  3773.     inline void processfds(T_FD_SET &s,byte mode,SelectItemArray &tonotify)
    3774. 

  3774.     {
    3775. 

  3775.         loop {
    3776. 

  3776.             T_SOCKET sock = popfds(s);
    3777. 

  3777.             if (!sock)
    3778. 

  3778.                 break;
    3779. 

  3779.             if (sock!=dummysock) {
    3780. 

  3780.                 SelectItem si = findhash(sock); // nb copies
    3781. 

  3781.                 if (!si.del) {
    3782. 

  3782.                     si.mode = mode;
    3783. 

  3783.                     tonotify.append(si);
    3784. 

  3784.                 }
    3785. 

  3785.             }
    3786. 

  3786.         }   
    3787. 

  3787.     }
    3788. 

  3788. 

  3789. #endif 
    3790. 

  3790. public:
    3791. 

  3791.     IMPLEMENT_IINTERFACE;
    3792. 

  3792.     CSocketSelectThread(const char *trc)
    3793. 

  3793.         : CSocketBaseThread("CSocketSelectThread")
    3794. 

  3794.     {
    3795. 

  3795.         dummysockopen = false;
    3796. 

  3796.         opendummy();
    3797. 

  3797.         terminating = false;
    3798. 

  3798.         atomic_set(&tickwait,0);
    3799. 

  3799.         waitingchange = 0;
    3800. 

  3800.         selectvarschange = false;
    3801. 

  3801.         validateselecterror = 0;
    3802. 

  3802.         validateerrcount = 0;
    3803. 

  3803.         offset = 0;
    3804. 

  3804.         selecttrace = trc;
    3805. 

  3805.         basesize = 0;
    3806. 

  3806. #ifdef _WIN32
    3807. 

  3807.         inithash();
    3808. 

  3808. #endif      
    3809. 

  3809.     }
    3810. 

  3810. 

  3811.     ~CSocketSelectThread()
    3812. 

  3812.     {
    3813. 

  3813.         closedummy();
    3814. 

  3814.         ForEachItemIn(i,items) {
    3815. 

  3815.             try {
    3816. 

  3816.                 SelectItem &si = items.item(i);
    3817. 

  3817.                 si.sock->Release();
    3818. 

  3818.                 si.nfy->Release();
    3819. 

  3819.             }
    3820. 

  3820.             catch (IException *e) {
    3821. 

  3821.                 EXCLOG(e,"~CSocketSelectThread");
    3822. 

  3822.                 e->Release();
    3823. 

  3823.             }
    3824. 

  3824.         }
    3825. 

  3825.     }
    3826. 

  3826. 

  3827.     Owned<IException> termexcept;
    3828. 

  3828. 

  3829.     void updateItems()
    3830. 

  3830.     {
    3831. 

  3831.         // must be in CriticalBlock block(sect); 
    3832. 

  3832.         unsigned n = items.ordinality();
    3833. 

  3833.         bool hashupdateneeded = (n!=basesize); // additions all come at end
    3834. 

  3834.         for (unsigned i=0;i<n;) {
    3835. 

  3835.             SelectItem &si = items.item(i);
    3836. 

  3836.             if (si.del) {
    3837. 

  3837.                 si.nfy->Release();
    3838. 

  3838.                 try {
    3839. 

  3839. #ifdef SOCKTRACE
    3840. 

  3840.                     PROGLOG("CSocketSelectThread::updateItems release %d",si.handle);
    3841. 

  3841. #endif
    3842. 

  3842.                     si.sock->Release();
    3843. 

  3843.                 }
    3844. 

  3844.                 catch (IException *e) {
    3845. 

  3845.                     EXCLOG(e,"CSocketSelectThread::updateItems");
    3846. 

  3846.                     e->Release();
    3847. 

  3847.                 }
    3848. 

  3848.                 n--;
    3849. 

  3849.                 if (i<n) 
    3850. 

  3850.                     si = items.item(n);
    3851. 

  3851.                 items.remove(n);
    3852. 

  3852.                 hashupdateneeded = true;
    3853. 

  3853.             }
    3854. 

  3854.             else
    3855. 

  3855.                 i++;
    3856. 

  3856.         }
    3857. 

  3857.         assertex(n<=XFD_SETSIZE-1);
    3858. 

  3858. #ifdef _WIN32
    3859. 

  3859.         if (hashupdateneeded)
    3860. 

  3860.             reinithash();
    3861. 

  3861. #endif
    3862. 

  3862.         basesize = n;
    3863. 

  3863.     }
    3864. 

  3864. 

  3865. 

  3866.     bool add(ISocket *sock,unsigned mode,ISocketSelectNotify *nfy)
    3867. 

  3867.     {
    3868. 

  3868.         // maybe check once to prevent 1st delay? TBD
    3869. 

  3869.         CriticalBlock block(sect);
    3870. 

  3870.         unsigned n=0;
    3871. 

  3871.         ForEachItemIn(i,items) {
    3872. 

  3872.             SelectItem &si = items.item(i);
    3873. 

  3873.             if (!si.del) {
    3874. 

  3874.                 if (si.sock==sock) {
    3875. 

  3875.                     si.del = true;
    3876. 

  3876.                 }
    3877. 

  3877.                 else 
    3878. 

  3878.                     n++;
    3879. 

  3879.             }
    3880. 

  3880.         }
    3881. 

  3881.         if (n>=XFD_SETSIZE-1)   // leave 1 spare
    3882. 

  3882.             return false;
    3883. 

  3883.         SelectItem sn;
    3884. 

  3884.         sn.nfy = LINK(nfy);
    3885. 

  3885.         sn.sock = LINK(sock);
    3886. 

  3886.         sn.mode = (byte)mode;
    3887. 

  3887.         sn.handle = (T_SOCKET)sock->OShandle();
    3888. 

  3888.         CHECKSOCKRANGE(sn.handle);
    3889. 

  3889.         sn.del = false;
    3890. 

  3890.         sn.add_epoll = false;
    3891. 

  3891.         items.append(sn);
    3892. 

  3892.         selectvarschange = true;        
    3893. 

  3893.         triggerselect();
    3894. 

  3894.         return true;
    3895. 

  3895.     }
    3896. 

  3896. 

  3897.     void updateSelectVars(T_FD_SET &rdfds,T_FD_SET &wrfds,T_FD_SET &exfds,bool &isrd,bool &iswr,bool &isex,unsigned &ni,T_SOCKET &max_sockid)
    3898. 

  3898.     {
    3899. 

  3899.         CriticalBlock block(sect);
    3900. 

  3900.         selectvarschange = false;
    3901. 

  3901.         if (waitingchange) {
    3902. 

  3902.             waitingchangesem.signal(waitingchange);
    3903. 

  3903.             waitingchange = 0;
    3904. 

  3904.         }
    3905. 

  3905.         if (validateselecterror) { // something went wrong so check sockets
    3906. 

  3906.             validateerrcount++;
    3907. 

  3907.             if (!checkSocks()) {
    3908. 

  3908.                 // bad socket not found
    3909. 

  3909.                 PROGLOG("CSocketSelectThread::updateSelectVars cannot find socket error");
    3910. 

  3910.                 if (validateerrcount>10)
    3911. 

  3911.                     throw MakeStringException(-1,"CSocketSelectThread:Socket select error %d",validateselecterror);
    3912. 

  3912.             }
    3913. 

  3913.         }
    3914. 

  3914.         else
    3915. 

  3915.             validateerrcount = 0;
    3916. 

  3916.         updateItems();
    3917. 

  3917.         XFD_ZERO( &rdfds );
    3918. 

  3918.         XFD_ZERO( &wrfds );
    3919. 

  3919.         XFD_ZERO( &exfds );
    3920. 

  3920.         isrd=false;
    3921. 

  3921.         iswr=false;
    3922. 

  3922.         isex=false;
    3923. 

  3923. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3924. 

  3924.         max_sockid=dummysockopen?dummysock[0]:0;
    3925. 

  3925. #else
    3926. 

  3926.         opendummy();
    3927. 

  3927.         max_sockid=dummysockopen?dummysock:0;
    3928. 

  3928. #endif
    3929. 

  3929.         ni = items.ordinality();
    3930. 

  3930. #ifdef _WIN32
    3931. 

  3931.         if (offset>=ni)
    3932. 

  3932. #endif
    3933. 

  3933.             offset = 0;
    3934. 

  3934.         unsigned j=offset;
    3935. 

  3935.         ForEachItemIn(i,items) {
    3936. 

  3936.             SelectItem &si = items.item(j);
    3937. 

  3937.             j++;
    3938. 

  3938.             if (j==ni)
    3939. 

  3939.                 j = 0;
    3940. 

  3940.             if (si.mode & SELECTMODE_READ) {
    3941. 

  3941.                 FD_SET( si.handle, &rdfds );
    3942. 

  3942.                 isrd = true;
    3943. 

  3943.             }
    3944. 

  3944.             if (si.mode & SELECTMODE_WRITE) {
    3945. 

  3945.                 FD_SET( si.handle, &wrfds );
    3946. 

  3946.                 iswr = true;
    3947. 

  3947.             }
    3948. 

  3948.             if (si.mode & SELECTMODE_EXCEPT) {
    3949. 

  3949.                 FD_SET( si.handle, &exfds );
    3950. 

  3950.                 isex = true;
    3951. 

  3951.             }
    3952. 

  3952.             max_sockid=std::max(si.handle, max_sockid);
    3953. 

  3953.         }
    3954. 

  3954.         if (dummysockopen) {
    3955. 

  3955. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    3956. 

  3956.             FD_SET( dummysock[0], &rdfds );
    3957. 

  3957.             isrd = true;
    3958. 

  3958. #else
    3959. 

  3959.             FD_SET( dummysock, &exfds );
    3960. 

  3960.             isex = true;
    3961. 

  3961. #endif
    3962. 

  3962.         }
    3963. 

  3963.         validateselecterror = 0;
    3964. 

  3964.         max_sockid++;
    3965. 

  3965. #ifdef SOCKTRACE
    3966. 

  3966.         PROGLOG("SOCKTRACE: selecting on %d sockets",ni);
    3967. 

  3967. #endif
    3968. 

  3968.     }
    3969. 

  3969. 

  3970.     int run()
    3971. 

  3971.     {
    3972. 

  3972.         try {
    3973. 

  3973.             T_FD_SET rdfds;
    3974. 

  3974.             T_FD_SET wrfds;
    3975. 

  3975.             T_FD_SET exfds;
    3976. 

  3976.             timeval selecttimeout;
    3977. 

  3977.             bool isrd = false;
    3978. 

  3978.             bool iswr = false;
    3979. 

  3979.             bool isex = false;
    3980. 

  3980.             T_SOCKET maxsockid = 0;
    3981. 

  3981.             unsigned ni = 0;
    3982. 

  3982.             selectvarschange = true;
    3983. 

  3983.             unsigned numto = 0;
    3984. 

  3984.             unsigned lastnumto = 0;
    3985. 

  3985.             unsigned totnum = 0;
    3986. 

  3986.             unsigned total = 0;
    3987. 

  3987. 

  3988. 

  3989.             while (!terminating) {
    3990. 

  3990.                 selecttimeout.tv_sec = SELECT_TIMEOUT_SECS;         // linux modifies so initialize inside loop
    3991. 

  3991.                 selecttimeout.tv_usec = 0;
    3992. 

  3992.                 if (selectvarschange) {
    3993. 

  3993.                     updateSelectVars(rdfds,wrfds,exfds,isrd,iswr,isex,ni,maxsockid);
    3994. 

  3994.                 }
    3995. 

  3995.                 if (ni==0) {
    3996. 

  3996.                     validateerrcount = 0;
    3997. 

  3997.                     atomic_inc(&tickwait);                  
    3998. 

  3998.                     if(!selectvarschange&&!terminating) 
    3999. 

  3999.                     ticksem.wait(SELECT_TIMEOUT_SECS*1000);
    4000. 

  4000.                     atomic_dec(&tickwait);
    4001. 

  4001.                         
    4002. 

  4002.                     continue;
    4003. 

  4003.                 }
    4004. 

  4004.                 T_FD_SET rs;
    4005. 

  4005.                 T_FD_SET ws;
    4006. 

  4006.                 T_FD_SET es;
    4007. 

  4007.                 T_FD_SET *rsp = isrd?cpyfds(rs,rdfds):NULL;
    4008. 

  4008.                 T_FD_SET *wsp = iswr?cpyfds(ws,wrfds):NULL;
    4009. 

  4009.                 T_FD_SET *esp = isex?cpyfds(es,exfds):NULL;
    4010. 

  4010.                 int n = ::select(maxsockid,(fd_set *)rsp,(fd_set *)wsp,(fd_set *)esp,&selecttimeout); // first parameter needed for posix
    4011. 

  4011.                 if (terminating)
    4012. 

  4012.                     break;
    4013. 

  4013.                 if (n < 0) {
    4014. 

  4014.                     CriticalBlock block(sect);
    4015. 

  4015.                     int err = ERRNO();
    4016. 

  4016.                     if (err != EINTRCALL) {
    4017. 

  4017.                         if (dummysockopen) {
    4018. 

  4018.                             LOGERR(err,12,"CSocketSelectThread select error"); // should cache error ?
    4019. 

  4019.                             validateselecterror = err;
    4020. 

  4020. #ifndef _USE_PIPE_FOR_SELECT_TRIGGER
    4021. 

  4021.                             closedummy();  // just in case was culprit
    4022. 

  4022. #endif
    4023. 

  4023.                         }
    4024. 

  4024.                         selectvarschange = true;
    4025. 

  4025.                         continue;
    4026. 

  4026.                     }
    4027. 

  4027.                     n = 0;
    4028. 

  4028.                 }
    4029. 

  4029.                 else if (n>0) { 
    4030. 

  4030.                     validateerrcount = 0;
    4031. 

  4031.                     numto = 0;
    4032. 

  4032.                     lastnumto = 0;
    4033. 

  4033.                     total += n;
    4034. 

  4034.                     totnum++;
    4035. 

  4035.                     SelectItemArray tonotify;
    4036. 

  4036.                     { 
    4037. 

  4037.                         CriticalBlock block(sect);
    4038. 

  4038. #ifdef _WIN32
    4039. 

  4039.                         if (isrd) 
    4040. 

  4040.                             processfds(rs,SELECTMODE_READ,tonotify);
    4041. 

  4041.                         if (iswr) 
    4042. 

  4042.                             processfds(ws,SELECTMODE_WRITE,tonotify);
    4043. 

  4043.                         if (isex) 
    4044. 

  4044.                             processfds(es,SELECTMODE_EXCEPT,tonotify);
    4045. 

  4045. #else
    4046. 

  4046.                         unsigned i;
    4047. 

  4047.                         SelectItem *si = items.getArray(offset);
    4048. 

  4048.                         SelectItem *sie = items.getArray(ni-1)+1;
    4049. 

  4049.                         bool r = isrd;
    4050. 

  4050.                         bool w = iswr;
    4051. 

  4051.                         bool e = isex;
    4052. 

  4052. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    4053. 

  4053.                         if (r&&dummysockopen&&findfds(rs,dummysock[0],r)) {
    4054. 

  4054.                             resettrigger();
    4055. 

  4055.                             --n;
    4056. 

  4056.                         }           
    4057. 

  4057. #endif
    4058. 

  4058.                         for (i=0;(n>0)&&(i<ni);i++) {
    4059. 

  4059.                             if (r&&findfds(rs,si->handle,r)) {
    4060. 

  4060.                                 if (!si->del) {
    4061. 

  4061.                                     tonotify.append(*si);
    4062. 

  4062.                                     tonotify.item(tonotify.length()-1).mode = SELECTMODE_READ;
    4063. 

  4063.                                 }
    4064. 

  4064.                                 --n;
    4065. 

  4065.                             }
    4066. 

  4066.                             if (w&&findfds(ws,si->handle,w)) {
    4067. 

  4067.                                 if (!si->del) {
    4068. 

  4068.                                     tonotify.append(*si);
    4069. 

  4069.                                     tonotify.item(tonotify.length()-1).mode = SELECTMODE_WRITE;
    4070. 

  4070.                                 }
    4071. 

  4071.                                 --n;
    4072. 

  4072.                             }
    4073. 

  4073.                             if (e&&findfds(es,si->handle,e)) {
    4074. 

  4074.                                 if (!si->del) {
    4075. 

  4075.                                     tonotify.append(*si);
    4076. 

  4076.                                     tonotify.item(tonotify.length()-1).mode = SELECTMODE_EXCEPT;
    4077. 

  4077.                                 }
    4078. 

  4078.                                 --n;
    4079. 

  4079.                             }
    4080. 

  4080.                             si++;
    4081. 

  4081.                             if (si==sie)
    4082. 

  4082.                                 si = items.getArray();
    4083. 

  4083.                         }
    4084. 

  4084. #endif
    4085. 

  4085.                     }
    4086. 

  4086.                     ForEachItemIn(j,tonotify) {
    4087. 

  4087.                         SelectItem &si = tonotify.item(j);
    4088. 

  4088.                         try {
    4089. 

  4089.                             si.nfy->notifySelected(si.sock,si.mode); // ignore return
    4090. 

  4090.                         }
    4091. 

  4091.                         catch (IException *e) { // should be acted upon by notifySelected
    4092. 

  4092.                             EXCLOG(e,"CSocketSelectThread notifySelected");
    4093. 

  4093.                             throw ;
    4094. 

  4094.                         }
    4095. 

  4095.                     }
    4096. 

  4096.                 }
    4097. 

  4097.                 else  {
    4098. 

  4098.                     validateerrcount = 0;
    4099. 

  4099.                     if ((++numto>=lastnumto*2)) {
    4100. 

  4100.                         lastnumto = numto;
    4101. 

  4101.                         if (selecttrace&&(numto>4))
    4102. 

  4102.                             PROGLOG("%s: Select Idle(%d), %d,%d,%0.2f",selecttrace,numto,totnum,total,totnum?((double)total/(double)totnum):0.0);
    4103. 

  4103.                     }   
    4104. 

  4104. /*
    4105. 

  4105.                     if (numto&&(numto%100)) {
    4106. 

  4106.                         CriticalBlock block(sect);
    4107. 

  4107.                         if (!selectvarschange) 
    4108. 

  4108.                             selectvarschange = checkSocks();
    4109. 

  4109.                     }
    4110. 

  4110. */
    4111. 

  4111.                 }
    4112. 

  4112.                 if (++offset>=ni)
    4113. 

  4113.                     offset = 0;
    4114. 

  4114. 

  4115.             }
    4116. 

  4116.         }
    4117. 

  4117.         catch (IException *e) {
    4118. 

  4118.             EXCLOG(e,"CSocketSelectThread");
    4119. 

  4119.             termexcept.setown(e);
    4120. 

  4120.         }
    4121. 

  4121.         CriticalBlock block(sect);
    4122. 

  4122.         try {
    4123. 

  4123.             updateItems();
    4124. 

  4124.         }
    4125. 

  4125.         catch (IException *e) {
    4126. 

  4126.             EXCLOG(e,"CSocketSelectThread(2)");
    4127. 

  4127.             if (!termexcept)
    4128. 

  4128.                 termexcept.setown(e);
    4129. 

  4129.             else
    4130. 

  4130.                 e->Release();
    4131. 

  4131.         }
    4132. 

  4132.         return 0;
    4133. 

  4133.     }
    4134. 

  4134. };
    4135. 

  4135. 

  4136. 

  4137. class CSocketSelectHandler: public CInterface, implements ISocketSelectHandler
    4138. 

  4138. {
    4139. 

  4139.     CIArrayOf<CSocketSelectThread> threads;
    4140. 

  4140.     CriticalSection sect;
    4141. 

  4141.     bool started;
    4142. 

  4142.     StringAttr selecttrace;
    4143. 

  4143. public:
    4144. 

  4144.     IMPLEMENT_IINTERFACE;
    4145. 

  4145.     CSocketSelectHandler(const char *trc)
    4146. 

  4146.         : selecttrace(trc)
    4147. 

  4147.     {
    4148. 

  4148.         started = false;
    4149. 

  4149.     }
    4150. 

  4150.     void start()
    4151. 

  4151.     {
    4152. 

  4152.         CriticalBlock block(sect);
    4153. 

  4153.         if (!started) {
    4154. 

  4154.             started = true;
    4155. 

  4155.             ForEachItemIn(i,threads) {
    4156. 

  4156.                 threads.item(i).start();
    4157. 

  4157.             }
    4158. 

  4158.         }
    4159. 

  4159.             
    4160. 

  4160.     }
    4161. 

  4161.     void add(ISocket *sock,unsigned mode,ISocketSelectNotify *nfy)
    4162. 

  4162.     {
    4163. 

  4163.         CriticalBlock block(sect);
    4164. 

  4164.         loop {
    4165. 

  4165.             bool added=false;
    4166. 

  4166.             ForEachItemIn(i,threads) {
    4167. 

  4167.                 if (added)
    4168. 

  4168.                     threads.item(i).remove(sock);
    4169. 

  4169.                 else
    4170. 

  4170.                     added = threads.item(i).add(sock,mode,nfy);
    4171. 

  4171.             }
    4172. 

  4172.             if (added)
    4173. 

  4173.                 return;
    4174. 

  4174.             CSocketSelectThread *thread = new CSocketSelectThread(selecttrace);
    4175. 

  4175.             threads.append(*thread);
    4176. 

  4176.             if (started)
    4177. 

  4177.                 thread->start();
    4178. 

  4178.         }
    4179. 

  4179.     }
    4180. 

  4180.     void remove(ISocket *sock)
    4181. 

  4181.     {
    4182. 

  4182.         CriticalBlock block(sect);
    4183. 

  4183.         ForEachItemIn(i,threads) {
    4184. 

  4184.             if (threads.item(i).remove(sock)&&sock)
    4185. 

  4185.                 break;
    4186. 

  4186.         }
    4187. 

  4187.     }
    4188. 

  4188.     void stop(bool wait)
    4189. 

  4189.     {
    4190. 

  4190.         IException *e=NULL;
    4191. 

  4191.         CriticalBlock block(sect);
    4192. 

  4192.         unsigned i = 0;
    4193. 

  4193.         while (i<threads.ordinality()) {
    4194. 

  4194.             CSocketSelectThread &t=threads.item(i);
    4195. 

  4195.             {
    4196. 

  4196.                 CriticalUnblock unblock(sect);
    4197. 

  4197.                 t.stop(wait);           // not quite as quick as could be if wait true
    4198. 

  4198.             }
    4199. 

  4199.             if (wait && !e && t.termexcept)
    4200. 

  4200.                 e = t.termexcept.getClear();
    4201. 

  4201.             i++;
    4202. 

  4202.         }
    4203. 

  4203. #if 0 // don't throw error as too late
    4204. 

  4204.         if (e)
    4205. 

  4205.             throw e;
    4206. 

  4206. #else
    4207. 

  4207.         ::Release(e);
    4208. 

  4208. #endif
    4209. 

  4209.     }
    4210. 

  4210. };
    4211. 

  4211. 

  4212. #ifdef _HAS_EPOLL_SUPPORT
    4213. 

  4213. class CSocketEpollThread: public CSocketBaseThread
    4214. 

  4214. {
    4215. 

  4215.     int epfd;
    4216. 

  4216.     int *epfdtbl; // table of fd<->item index for lookups
    4217. 

  4217.     struct epoll_event *epevents;
    4218. 

  4218. 

  4219.     void epoll_op(int efd, int op, int fd, unsigned int event_mask)
    4220. 

  4220.     {
    4221. 

  4221.         int srtn;
    4222. 

  4222.         struct epoll_event event;
    4223. 

  4223.         event.events = event_mask;
    4224. 

  4224.         event.data.fd = fd;
    4225. 

  4225. # ifdef EPOLLTRACE
    4226. 

  4226.         DBGLOG("EPOLL: op(%d) fd %d to epfd %d", op, fd, efd);
    4227. 

  4227. # endif
    4228. 

  4228.         srtn = ::epoll_ctl(efd, op, fd, &event);
    4229. 

  4229.         // if another thread closed fd before here don't fail
    4230. 

  4230.         if ( (srtn < 0) && (op != EPOLL_CTL_DEL) ){
    4231. 

  4231.             int err = ERRNO();
    4232. 

  4232.             LOGERR(err,1,"epoll_ctl");
    4233. 

  4233.             THROWJSOCKEXCEPTION2(err);
    4234. 

  4234.         }
    4235. 

  4235.     }
    4236. 

  4236. 

  4237.     void opendummy()
    4238. 

  4238.     {
    4239. 

  4239.         CriticalBlock block(sect);
    4240. 

  4240.         if (!dummysockopen) {
    4241. 

  4241. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    4242. 

  4242.             if(pipe(dummysock)) {
    4243. 

  4243.                 WARNLOG("CSocketEpollThread: create pipe failed %d",ERRNO());
    4244. 

  4244.                 return;
    4245. 

  4245.             }
    4246. 

  4246.             for (unsigned i=0;i<2;i++) {
    4247. 

  4247.                 int flags = fcntl(dummysock[i], F_GETFL, 0);
    4248. 

  4248.                 if (flags!=-1) {
    4249. 

  4249.                     flags |= O_NONBLOCK;
    4250. 

  4250.                     fcntl(dummysock[i], F_SETFL, flags);
    4251. 

  4251.                 }
    4252. 

  4252.                 flags = fcntl(dummysock[i], F_GETFD, 0);
    4253. 

  4253.                 if (flags!=-1) {
    4254. 

  4254.                     flags |=  FD_CLOEXEC;
    4255. 

  4255.                     fcntl(dummysock[i], F_SETFD, flags);
    4256. 

  4256.                 }
    4257. 

  4257.             }
    4258. 

  4258.             CHECKSOCKRANGE(dummysock[0]);
    4259. 

  4259.             epoll_op(epfd, EPOLL_CTL_ADD, dummysock[0], EPOLLIN);
    4260. 

  4260. #else
    4261. 

  4261.             if (IP6preferred)
    4262. 

  4262.                 dummysock = ::socket(AF_INET6, SOCK_STREAM, PF_INET6);
    4263. 

  4263.             else
    4264. 

  4264.                 dummysock = ::socket(AF_INET, SOCK_STREAM, 0);
    4265. 

  4265.             CHECKSOCKRANGE(dummysock);
    4266. 

  4266.             epoll_op(epfd, EPOLL_CTL_ADD, dummysock, (EPOLLIN | EPOLLERR));
    4267. 

  4267. #endif
    4268. 

  4268.             dummysockopen = true;
    4269. 

  4269.         }
    4270. 

  4270. 

  4271. 

  4272.     }
    4273. 

  4273. 

  4274.     void closedummy()
    4275. 

  4275.     {
    4276. 

  4276.         CriticalBlock block(sect);
    4277. 

  4277.         if (dummysockopen) {
    4278. 

  4278. #ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    4279. 

  4279.             epoll_op(epfd, EPOLL_CTL_DEL, dummysock[0], 0);
    4280. 

  4280. #ifdef SOCKTRACE
    4281. 

  4281.             PROGLOG("SOCKTRACE: Closing dummy sockets %x %d %x %d (%x)", dummysock[0], dummysock[0], dummysock[1], dummysock[1], this);
    4282. 

  4282. #endif
    4283. 

  4283.             ::close(dummysock[0]);
    4284. 

  4284.             ::close(dummysock[1]);
    4285. 

  4285. #else
    4286. 

  4286.             epoll_op(epfd, EPOLL_CTL_DEL, dummysock, 0);
    4287. 

  4287.             ::close(dummysock);
    4288. 

  4288. #endif
    4289. 

  4289.             dummysockopen = false;
    4290. 

  4290.         }
    4291. 

  4291.     }
    4292. 

  4292. 

  4293. 

  4294. public:
    4295. 

  4295.     IMPLEMENT_IINTERFACE;
    4296. 

  4296.     CSocketEpollThread(const char *trc)
    4297. 

  4297.         : CSocketBaseThread("CSocketEpollThread")
    4298. 

  4298.     {
    4299. 

  4299.         dummysockopen = false;
    4300. 

  4300.         terminating = false;
    4301. 

  4301.         atomic_set(&tickwait,0);
    4302. 

  4302.         waitingchange = 0;
    4303. 

  4303.         selectvarschange = false;
    4304. 

  4304.         validateselecterror = 0;
    4305. 

  4305.         validateerrcount = 0;
    4306. 

  4306.         offset = 0;
    4307. 

  4307.         selecttrace = trc;
    4308. 

  4308.         epfd = ::epoll_create(XFD_SETSIZE);
    4309. 

  4309.         if (epfd < 0) {
    4310. 

  4310.           int err = ERRNO();
    4311. 

  4311.           LOGERR(err,1,"epoll_create()");
    4312. 

  4312.           THROWJSOCKEXCEPTION2(err);
    4313. 

  4313.         }
    4314. 

  4314. # ifdef EPOLLTRACE
    4315. 

  4315.         DBGLOG("CSocketEpollThread: creating epoll fd %d", epfd );
    4316. 

  4316. # endif
    4317. 

  4317.         try {
    4318. 

  4318.             epfdtbl = new int[XFD_SETSIZE];
    4319. 

  4319.         } catch (const std::bad_alloc &e) {
    4320. 

  4320.             int err = ERRNO();
    4321. 

  4321.             LOGERR(err,1,"epfdtbl alloc()");
    4322. 

  4322.             THROWJSOCKEXCEPTION2(err);
    4323. 

  4323.         }
    4324. 

  4324.         for (int i=0; i<XFD_SETSIZE; i++) {
    4325. 

  4325.             epfdtbl[i] = -1;
    4326. 

  4326.         }
    4327. 

  4327.         try {
    4328. 

  4328.             epevents = new struct epoll_event[XFD_SETSIZE];
    4329. 

  4329.         } catch (const std::bad_alloc &e) {
    4330. 

  4330.             int err = ERRNO();
    4331. 

  4331.             LOGERR(err,1,"epevents alloc()");
    4332. 

  4332.             THROWJSOCKEXCEPTION2(err);
    4333. 

  4333.         }
    4334. 

  4334.         opendummy();
    4335. 

  4335.     }
    4336. 

  4336. 

  4337.     ~CSocketEpollThread()
    4338. 

  4338.     {
    4339. 

  4339.         closedummy();
    4340. 

  4340.         ForEachItemIn(i,items) {
    4341. 

  4341.             try {
    4342. 

  4342.                 SelectItem &si = items.item(i);
    4343. 

  4343.                 epoll_op(epfd, EPOLL_CTL_DEL, si.handle, 0);
    4344. 

  4344.                 si.sock->Release();
    4345. 

  4345.                 si.nfy->Release();
    4346. 

  4346.             }
    4347. 

  4347.             catch (IException *e) {
    4348. 

  4348.                 EXCLOG(e,"~CSocketEpollThread");
    4349. 

  4349.                 e->Release();
    4350. 

  4350.             }
    4351. 

  4351.         }
    4352. 

  4352.         if (epfd >= 0) {
    4353. 

  4353. # ifdef EPOLLTRACE
    4354. 

  4354.             DBGLOG("EPOLL: closing epfd %d", epfd );
    4355. 

  4355. # endif
    4356. 

  4356.             ::close(epfd);
    4357. 

  4357.             epfd = -1;
    4358. 

  4358.             delete [] epfdtbl;
    4359. 

  4359.             delete [] epevents;
    4360. 

  4360.         }
    4361. 

  4361.     }
    4362. 

  4362. 

  4363.     Owned<IException> termexcept;
    4364. 

  4364. 

  4365.     void updateItems()
    4366. 

  4366.     {
    4367. 

  4367.         // must be in CriticalBlock block(sect);
    4368. 

  4368.         unsigned n = items.ordinality();
    4369. 

  4369.         bool reindex = false;
    4370. 

  4370.         for (unsigned i=0;i<n;) {
    4371. 

  4371.             SelectItem &si = items.item(i);
    4372. 

  4372.             if (si.add_epoll) {
    4373. 

  4373.                 reindex = true;
    4374. 

  4374.             }
    4375. 

  4375.             if (si.del) {
    4376. 

  4376.                 epoll_op(epfd, EPOLL_CTL_DEL, si.handle, 0);
    4377. 

  4377.                 epfdtbl[si.handle] = -1;
    4378. 

  4378.                 reindex = true;
    4379. 

  4379.                 si.nfy->Release();
    4380. 

  4380.                 try {
    4381. 

  4381. #ifdef SOCKTRACE
    4382. 

  4382.                     PROGLOG("CSocketEpollThread::updateItems release %d",si.handle);
    4383. 

  4383. #endif
    4384. 

  4384.                     si.sock->Release();
    4385. 

  4385.                 }
    4386. 

  4386.                 catch (IException *e) {
    4387. 

  4387.                     EXCLOG(e,"CSocketEpollThread::updateItems");
    4388. 

  4388.                     e->Release();
    4389. 

  4389.                 }
    4390. 

  4390.                 n--;
    4391. 

  4391.                 if (i<n)
    4392. 

  4392.                     si = items.item(n);
    4393. 

  4393.                 items.remove(n);
    4394. 

  4394.             }
    4395. 

  4395.             else
    4396. 

  4396.                 i++;
    4397. 

  4397.         }
    4398. 

  4398.         assertex(n<=XFD_SETSIZE-1);
    4399. 

  4399.         if (reindex) {
    4400. 

  4400. # ifdef EPOLLTRACE
    4401. 

  4401.             int max_sockid = 0;
    4402. 

  4402. # endif
    4403. 

  4403.             ForEachItemIn(j,items) {
    4404. 

  4404.                 SelectItem &si = items.item(j);
    4405. 

  4405.                 epfdtbl[si.handle] = j;
    4406. 

  4406.                 if (si.add_epoll) {
    4407. 

  4407.                     si.add_epoll = false;
    4408. 

  4408.                     int srtn, ep_mode;
    4409. 

  4409.                     struct epoll_event event;
    4410. 

  4410.                     if (si.mode != 0) {
    4411. 

  4411.                         ep_mode = 0;
    4412. 

  4412.                         if (si.mode & SELECTMODE_READ) {
    4413. 

  4413.                             ep_mode |= (EPOLLIN | EPOLLPRI);
    4414. 

  4414.                         }
    4415. 

  4415.                         if (si.mode & SELECTMODE_WRITE) {
    4416. 

  4416.                             ep_mode |= EPOLLOUT;
    4417. 

  4417.                         }
    4418. 

  4418.                         if (si.mode & SELECTMODE_EXCEPT) {
    4419. 

  4419.                             ep_mode |= EPOLLERR;
    4420. 

  4420.                         }
    4421. 

  4421.                         if (ep_mode != 0) {
    4422. 

  4422.                             ep_mode |= EPOLLRDHUP;
    4423. 

  4423.                             epoll_op(epfd, EPOLL_CTL_ADD, si.handle, ep_mode);
    4424. 

  4424.                         }
    4425. 

  4425.                     }
    4426. 

  4426. # ifdef EPOLLTRACE
    4427. 

  4427.                     max_sockid=std::max(si.handle, max_sockid);
    4428. 

  4428. # endif
    4429. 

  4429.                 }
    4430. 

  4430. # ifdef EPOLLTRACE
    4431. 

  4431.                 for(int ix=0; ix<=max_sockid; ix++) {
    4432. 

  4432.                     DBGLOG("EPOLL: epfdtbl[%d] = %d", ix, epfdtbl[ix]);
    4433. 

  4433.                 }
    4434. 

  4434. # endif
    4435. 

  4435.             }
    4436. 

  4436. # ifdef EPOLLTRACE
    4437. 

  4437.             DBGLOG("EPOLL: leaving updateItems(), reindex = %d", reindex);
    4438. 

  4438. # endif
    4439. 

  4439.         }
    4440. 

  4440.     }
    4441. 

  4441. 

  4442.     bool add(ISocket *sock,unsigned mode,ISocketSelectNotify *nfy)
    4443. 

  4443.     {
    4444. 

  4444.         // maybe check once to prevent 1st delay? TBD
    4445. 

  4445.         CriticalBlock block(sect);
    4446. 

  4446.         unsigned n=0;
    4447. 

  4447.         ForEachItemIn(i,items) {
    4448. 

  4448.             SelectItem &si = items.item(i);
    4449. 

  4449.             if (!si.del) {
    4450. 

  4450.                 if (si.sock==sock) {
    4451. 

  4451.                     si.del = true;
    4452. 

  4452.                 }
    4453. 

  4453.                 else
    4454. 

  4454.                     n++;
    4455. 

  4455.             }
    4456. 

  4456.         }
    4457. 

  4457.         if (n>=XFD_SETSIZE-1)   // leave 1 spare
    4458. 

  4458.             return false;
    4459. 

  4459.         SelectItem sn;
    4460. 

  4460.         sn.nfy = LINK(nfy);
    4461. 

  4461.         sn.sock = LINK(sock);
    4462. 

  4462.         sn.mode = (byte)mode;
    4463. 

  4463.         sn.handle = (T_SOCKET)sock->OShandle();
    4464. 

  4464.         CHECKSOCKRANGE(sn.handle);
    4465. 

  4465.         sn.del = false;
    4466. 

  4466.         sn.add_epoll = true;
    4467. 

  4467.         items.append(sn);
    4468. 

  4468.         selectvarschange = true;
    4469. 

  4469.         triggerselect();
    4470. 

  4470.         return true;
    4471. 

  4471.     }
    4472. 

  4472. 

  4473.     void updateEpollVars(unsigned &ni)
    4474. 

  4474.     {
    4475. 

  4475.         CriticalBlock block(sect);
    4476. 

  4476.         selectvarschange = false;
    4477. 

  4477.         if (waitingchange) {
    4478. 

  4478.             waitingchangesem.signal(waitingchange);
    4479. 

  4479.             waitingchange = 0;
    4480. 

  4480.         }
    4481. 

  4481.         if (validateselecterror) { // something went wrong so check sockets
    4482. 

  4482.             validateerrcount++;
    4483. 

  4483.             if (!checkSocks()) {
    4484. 

  4484.                 // bad socket not found
    4485. 

  4485.                 PROGLOG("CSocketEpollThread::updateEpollVars cannot find socket error");
    4486. 

  4486.                 if (validateerrcount>10)
    4487. 

  4487.                     throw MakeStringException(-1,"CSocketEpollThread:Socket epoll error %d",validateselecterror);
    4488. 

  4488.             }
    4489. 

  4489.         }
    4490. 

  4490.         else
    4491. 

  4491.             validateerrcount = 0;
    4492. 

  4492.         updateItems();
    4493. 

  4493. #ifndef _USE_PIPE_FOR_SELECT_TRIGGER
    4494. 

  4494.         opendummy();
    4495. 

  4495. #endif
    4496. 

  4496.         ni = items.ordinality();
    4497. 

  4497.         validateselecterror = 0;
    4498. 

  4498.     }
    4499. 

  4499. 

  4500.     int run()
    4501. 

  4501.     {
    4502. 

  4502.         try {
    4503. 

  4503.             unsigned ni = 0;
    4504. 

  4504.             unsigned numto = 0;
    4505. 

  4505.             unsigned lastnumto = 0;
    4506. 

  4506.             unsigned totnum = 0;
    4507. 

  4507.             unsigned total = 0;
    4508. 

  4508.             selectvarschange = true;
    4509. 

  4509. 

  4510.             while (!terminating) {
    4511. 

  4511.                 if (selectvarschange) {
    4512. 

  4512.                         updateEpollVars(ni);
    4513. 

  4513.                 }
    4514. 

  4514.                 if (ni==0) {
    4515. 

  4515.                     validateerrcount = 0;
    4516. 

  4516.                     atomic_inc(&tickwait);
    4517. 

  4517.                     if(!selectvarschange&&!terminating)
    4518. 

  4518.                         ticksem.wait(SELECT_TIMEOUT_SECS*1000);
    4519. 

  4519.                     atomic_dec(&tickwait);
    4520. 

  4520. 

  4521.                     continue;
    4522. 

  4522.                 }
    4523. 

  4523. 

  4524.                 int n = ::epoll_wait(epfd, epevents, XFD_SETSIZE, 1000);
    4525. 

  4525. 

  4526. # ifdef EPOLLTRACE
    4527. 

  4527.                 if(n > 0)
    4528. 

  4528.                     DBGLOG("EPOLL: after epoll_wait(), n = %d, ni = %d", n, ni);
    4529. 

  4529. # endif
    4530. 

  4530. 

  4531.                 if (terminating)
    4532. 

  4532.                     break;
    4533. 

  4533.                 if (n < 0) {
    4534. 

  4534.                     CriticalBlock block(sect);
    4535. 

  4535.                     int err = ERRNO();
    4536. 

  4536.                     if (err != EINTRCALL) {
    4537. 

  4537.                         if (dummysockopen) {
    4538. 

  4538.                             LOGERR(err,12,"CSocketEpollThread epoll error"); // should cache error ?
    4539. 

  4539.                             validateselecterror = err;
    4540. 

  4540. #ifndef _USE_PIPE_FOR_SELECT_TRIGGER
    4541. 

  4541.                             closedummy();  // just in case was culprit
    4542. 

  4542. #endif
    4543. 

  4543.                         }
    4544. 

  4544.                         selectvarschange = true;
    4545. 

  4545.                         continue;
    4546. 

  4546.                     }
    4547. 

  4547.                     n = 0;
    4548. 

  4548.                 }
    4549. 

  4549.                 else if (n>0) {
    4550. 

  4550.                     validateerrcount = 0;
    4551. 

  4551.                     numto = 0;
    4552. 

  4552.                     lastnumto = 0;
    4553. 

  4553.                     total += n;
    4554. 

  4554.                     totnum++;
    4555. 

  4555.                     SelectItemArray tonotify;
    4556. 

  4556.                     {
    4557. 

  4557.                         CriticalBlock block(sect);
    4558. 

  4558. 

  4559.                         for (int j=0;j<n;j++) {
    4560. 

  4560. # ifdef EPOLLTRACE
    4561. 

  4561.                             DBGLOG("EPOLL: epevents[%d].data.fd = %d, epfdtbl = %d, emask = %d", j, epevents[j].data.fd, epfdtbl[epevents[j].data.fd], epevents[j].events);
    4562. 

  4562. # endif
    4563. 

  4563. # ifdef _USE_PIPE_FOR_SELECT_TRIGGER
    4564. 

  4564.                             if ((dummysockopen) && (epevents[j].data.fd == dummysock[0])) {
    4565. 

  4565.                                 resettrigger();
    4566. 

  4566.                                 continue;
    4567. 

  4567.                             }
    4568. 

  4568. # endif
    4569. 

  4569.                             if (epevents[j].data.fd >= 0) {
    4570. 

  4570.                                 assertex(epfdtbl[epevents[j].data.fd] >= 0);
    4571. 

  4571.                                 SelectItem *epsi = items.getArray(epfdtbl[epevents[j].data.fd]);
    4572. 

  4572.                                 if (!epsi->del) {
    4573. 

  4573.                                     unsigned int ep_mode = 0;
    4574. 

  4574.                                     if (epevents[j].events & (EPOLLIN | EPOLLPRI)) {
    4575. 

  4575.                                         ep_mode |= SELECTMODE_READ;
    4576. 

  4576.                                     }
    4577. 

  4577.                                     if (epevents[j].events & (EPOLLERR | EPOLLHUP)) {
    4578. 

  4578.                                         ep_mode |= SELECTMODE_READ;
    4579. 

  4579.                                     }
    4580. 

  4580.                                     if (epevents[j].events & EPOLLRDHUP) {
    4581. 

  4581.                                         // TODO - or should we set EXCEPT ?
    4582. 

  4582.                                         ep_mode |= SELECTMODE_READ;
    4583. 

  4583.                                     }
    4584. 

  4584.                                     if (epevents[j].events & EPOLLOUT) {
    4585. 

  4585.                                         ep_mode |= SELECTMODE_WRITE;
    4586. 

  4586.                                     }
    4587. 

  4587.                                     if (ep_mode != 0) {
    4588. 

  4588.                                         tonotify.append(*epsi);
    4589. 

  4589.                                         tonotify.item(tonotify.length()-1).mode = ep_mode;
    4590. 

  4590.                                     }
    4591. 

  4591.                                 }
    4592. 

  4592.                             }
    4593. 

  4593.                         }
    4594. 

  4594.                     }
    4595. 

  4595.                     ForEachItemIn(j,tonotify) {
    4596. 

  4596.                         SelectItem &si = tonotify.item(j);
    4597. 

  4597.                         try {
    4598. 

  4598.                             si.nfy->notifySelected(si.sock,si.mode); // ignore return
    4599. 

  4599.                         }
    4600. 

  4600.                         catch (IException *e) { // should be acted upon by notifySelected
    4601. 

  4601.                             EXCLOG(e,"CSocketEpollThread notifySelected");
    4602. 

  4602.                             throw ;
    4603. 

  4603.                         }
    4604. 

  4604.                     }
    4605. 

  4605.                 }
    4606. 

  4606.                 else  {
    4607. 

  4607.                     validateerrcount = 0;
    4608. 

  4608.                     if ((++numto>=lastnumto*2)) {
    4609. 

  4609.                         lastnumto = numto;
    4610. 

  4610.                         if (selecttrace&&(numto>4))
    4611. 

  4611.                             PROGLOG("%s: Epoll Idle(%d), %d,%d,%0.2f",selecttrace,numto,totnum,total,totnum?((double)total/(double)totnum):0.0);
    4612. 

  4612.                     }
    4613. 

  4613. /*
    4614. 

  4614.                     if (numto&&(numto%100)) {
    4615. 

  4615.                         CriticalBlock block(sect);
    4616. 

  4616.                         if (!selectvarschange)
    4617. 

  4617.                             selectvarschange = checkSocks();
    4618. 

  4618.                     }
    4619. 

  4619. */
    4620. 

  4620.                 }
    4621. 

  4621.             }
    4622. 

  4622.         }
    4623. 

  4623.         catch (IException *e) {
    4624. 

  4624.             EXCLOG(e,"CSocketEpollThread");
    4625. 

  4625.             termexcept.setown(e);
    4626. 

  4626.         }
    4627. 

  4627.         CriticalBlock block(sect);
    4628. 

  4628.         try {
    4629. 

  4629.             updateItems();
    4630. 

  4630.         }
    4631. 

  4631.         catch (IException *e) {
    4632. 

  4632.             EXCLOG(e,"CSocketEpollThread(2)");
    4633. 

  4633.             if (!termexcept)
    4634. 

  4634.                 termexcept.setown(e);
    4635. 

  4635.             else
    4636. 

  4636.                 e->Release();
    4637. 

  4637.         }
    4638. 

  4638.         return 0;
    4639. 

  4639.     }
    4640. 

  4640. 

  4641. };
    4642. 

  4642. 

  4643. class CSocketEpollHandler: public CInterface, implements ISocketSelectHandler
    4644. 

  4644. {
    4645. 

  4645.     CSocketEpollThread *epollthread;
    4646. 

  4646.     CriticalSection sect;
    4647. 

  4647.     bool started;
    4648. 

  4648.     StringAttr epolltrace;
    4649. 

  4649. public:
    4650. 

  4650.     IMPLEMENT_IINTERFACE;
    4651. 

  4651.     CSocketEpollHandler(const char *trc)
    4652. 

  4652.         : epolltrace(trc)
    4653. 

  4653.     {
    4654. 

  4654.         epollthread = new CSocketEpollThread(epolltrace);
    4655. 

  4655.     }
    4656. 

  4656. 

  4657.     ~CSocketEpollHandler()
    4658. 

  4658.     {
    4659. 

  4659.         delete epollthread;
    4660. 

  4660.     }
    4661. 

  4661. 

  4662.     void start()
    4663. 

  4663.     {
    4664. 

  4664.         CriticalBlock block(sect);
    4665. 

  4665.         epollthread->start();
    4666. 

  4666.     }
    4667. 

  4667. 

  4668.     void add(ISocket *sock,unsigned mode,ISocketSelectNotify *nfy)
    4669. 

  4669.     {
    4670. 

  4670.         CriticalBlock block(sect);
    4671. 

  4671.         epollthread->add(sock,mode,nfy);
    4672. 

  4672.     }
    4673. 

  4673. 

  4674.     void remove(ISocket *sock)
    4675. 

  4675.     {
    4676. 

  4676.         CriticalBlock block(sect);
    4677. 

  4677.         epollthread->remove(sock);
    4678. 

  4678.     }
    4679. 

  4679. 

  4680.     void stop(bool wait)
    4681. 

  4681.     {
    4682. 

  4682.         IException *e=NULL;
    4683. 

  4683.         epollthread->stop(wait);           // not quite as quick as could be if wait true
    4684. 

  4684.         if (wait && !e && epollthread->termexcept)
    4685. 

  4685.             e = epollthread->termexcept.getClear();
    4686. 

  4686. #if 0 // don't throw error as too late
    4687. 

  4687.         if (e)
    4688. 

  4688.             throw e;
    4689. 

  4689. #else
    4690. 

  4690.         ::Release(e);
    4691. 

  4691. #endif
    4692. 

  4692.     }
    4693. 

  4693. };
    4694. 

  4694. #endif // _HAS_EPOLL_SUPPORT
    4695. 

  4695. 

  4696. enum EpollMethod { EPOLL_INIT = 0, EPOLL_DISABLED, EPOLL_ENABLED };
    4697. 

  4697. static EpollMethod epoll_method = EPOLL_INIT;
    4698. 

  4698. static CriticalSection epollsect;
    4699. 

  4699. 

  4700. ISocketSelectHandler *createSocketSelectHandler(const char *trc)
    4701. 

  4701. {
    4702. 

  4702. #ifdef _HAS_EPOLL_SUPPORT
    4703. 

  4703.     {
    4704. 

  4704.         CriticalBlock block(epollsect);
    4705. 

  4705.         // DBGLOG("createSocketSelectHandler(): epoll_method = %d",epoll_method);
    4706. 

  4706.         if (epoll_method == EPOLL_INIT) {
    4707. 

  4707.             Owned<IProperties> conf = createProperties(CONFIG_DIR PATHSEPSTR "environment.conf", true);
    4708. 

  4708.             if (conf->getPropBool("use_epoll", true)) {
    4709. 

  4709.                 epoll_method = EPOLL_ENABLED;
    4710. 

  4710.             } else {
    4711. 

  4711.                 epoll_method = EPOLL_DISABLED;
    4712. 

  4712.             }
    4713. 

  4713.             // DBGLOG("createSocketSelectHandler(): after reading conf file, epoll_method = %d",epoll_method);
    4714. 

  4714.         }
    4715. 

  4715.     }
    4716. 

  4716.     if (epoll_method == EPOLL_ENABLED)
    4717. 

  4717.         return new CSocketEpollHandler(trc);
    4718. 

  4718.     else
    4719. 

  4719.         return new CSocketSelectHandler(trc);
    4720. 

  4720. #else
    4721. 

  4721.     return new CSocketSelectHandler(trc);
    4722. 

  4722. #endif
    4723. 

  4723. }
    4724. 

  4724. 

  4725. ISocketSelectHandler *createSocketEpollHandler(const char *trc)
    4726. 

  4726. {
    4727. 

  4727. #ifdef _HAS_EPOLL_SUPPORT
    4728. 

  4728.     return new CSocketEpollHandler(trc);
    4729. 

  4729. #else
    4730. 

  4730.     return new CSocketSelectHandler(trc);
    4731. 

  4731. #endif
    4732. 

  4732. }
    4733. 

  4733. 

  4734. void readBuffer(ISocket * socket, MemoryBuffer & buffer)
    4735. 

  4735. {
    4736. 

  4736.     size32_t len;
    4737. 

  4737.     socket->read(&len, sizeof(len));
    4738. 

  4738.     _WINREV4(len);
    4739. 

  4739.     if (len) {
    4740. 

  4740.         void * target = buffer.reserve(len);
    4741. 

  4741.         socket->read(target, len);
    4742. 

  4742.     }
    4743. 

  4743. }
    4744. 

  4744. 

  4745. void readBuffer(ISocket * socket, MemoryBuffer & buffer, unsigned timeoutms)
    4746. 

  4746. {
    4747. 

  4747.     size32_t len;
    4748. 

  4748.     size32_t sizeGot;
    4749. 

  4749.     socket->readtms(&len, sizeof(len), sizeof(len), sizeGot, timeoutms);
    4750. 

  4750.     _WINREV4(len);
    4751. 

  4751.     if (len) {
    4752. 

  4752.         void * target = buffer.reserve(len);
    4753. 

  4753.         socket->readtms(target, len, len, sizeGot, timeoutms);
    4754. 

  4754.     }
    4755. 

  4755. }
    4756. 

  4756. 

  4757. void writeBuffer(ISocket * socket, MemoryBuffer & buffer)
    4758. 

  4758. {
    4759. 

  4759.     unsigned len = buffer.length();
    4760. 

  4760.     _WINREV4(len);
    4761. 

  4761.     socket->write(&len, sizeof(len));
    4762. 

  4762.     if (len)
    4763. 

  4763.         socket->write(buffer.toByteArray(), buffer.length());
    4764. 

  4764. }
    4765. 

  4765. 

  4766. 

  4767. bool catchReadBuffer(ISocket * socket, MemoryBuffer & buffer)
    4768. 

  4768. {
    4769. 

  4769.     try
    4770. 

  4770.     {
    4771. 

  4771.         readBuffer(socket, buffer);
    4772. 

  4772.         return true;
    4773. 

  4773.     }
    4774. 

  4774.     catch (IException * e)
    4775. 

  4775.     {
    4776. 

  4776.         switch (e->errorCode())
    4777. 

  4777.         {
    4778. 

  4778.         case JSOCKERR_graceful_close:
    4779. 

  4779.             break;
    4780. 

  4780.         default:
    4781. 

  4781.             EXCLOG(e,"catchReadBuffer");
    4782. 

  4782.             break;
    4783. 

  4783.         }
    4784. 

  4784.         e->Release();
    4785. 

  4785.     }
    4786. 

  4786.     return false;
    4787. 

  4787. }
    4788. 

  4788. 

  4789. bool catchReadBuffer(ISocket * socket, MemoryBuffer & buffer, unsigned timeoutms)
    4790. 

  4790. {
    4791. 

  4791.     try
    4792. 

  4792.     {
    4793. 

  4793.         readBuffer(socket, buffer, timeoutms);
    4794. 

  4794.         return true;
    4795. 

  4795.     }
    4796. 

  4796.     catch (IException * e)
    4797. 

  4797.     {
    4798. 

  4798.         switch (e->errorCode())
    4799. 

  4799.         {
    4800. 

  4800.         case JSOCKERR_graceful_close:
    4801. 

  4801.             break;
    4802. 

  4802.         default:
    4803. 

  4803.             EXCLOG(e,"catchReadBuffer");
    4804. 

  4804.             break;
    4805. 

  4805.         }
    4806. 

  4806.         e->Release();
    4807. 

  4807.     }
    4808. 

  4808.     return false;
    4809. 

  4809. }
    4810. 

  4810. 

  4811. bool catchWriteBuffer(ISocket * socket, MemoryBuffer & buffer)
    4812. 

  4812. {
    4813. 

  4813.     try
    4814. 

  4814.     {
    4815. 

  4815.         writeBuffer(socket, buffer);
    4816. 

  4816.         return true;
    4817. 

  4817.     }
    4818. 

  4818.     catch (IException * e)
    4819. 

  4819.     {
    4820. 

  4820.         EXCLOG(e,"catchWriteBuffer");
    4821. 

  4821.         e->Release();
    4822. 

  4822.     }
    4823. 

  4823.     return false;
    4824. 

  4824. }
    4825. 

  4825. 

  4826. // utility interface for simple conversations 
    4827. 

  4827. // conversation is always between two ends, 
    4828. 

  4828. // at any given time one end must be receiving and other sending (though these may swap during the conversation)
    4829. 

  4829. class CSingletonSocketConnection: public CInterface, implements IConversation
    4830. 

  4830. {
    4831. 

  4831.     Owned<ISocket> sock;
    4832. 

  4832.     Owned<ISocket> listensock;
    4833. 

  4833.     enum { Snone, Saccept, Sconnect, Srecv, Ssend, Scancelled } state;
    4834. 

  4834.     bool accepting;
    4835. 

  4835.     bool cancelling;
    4836. 

  4836.     SocketEndpoint ep;
    4837. 

  4837.     CriticalSection crit;
    4838. 

  4838. public:
    4839. 

  4839.     IMPLEMENT_IINTERFACE;
    4840. 

  4840. 

  4841.     CSingletonSocketConnection(SocketEndpoint &_ep)
    4842. 

  4842.     {
    4843. 

  4843.         ep = _ep;
    4844. 

  4844.         state = Snone;
    4845. 

  4845.         cancelling = false;
    4846. 

  4846.     }
    4847. 

  4847. 

  4848.     ~CSingletonSocketConnection()
    4849. 

  4849.     {
    4850. 

  4850.         try {
    4851. 

  4851.             if (sock)
    4852. 

  4852.                 sock->close();
    4853. 

  4853.         }
    4854. 

  4854.         catch (IException *e) {
    4855. 

  4855.             if (e->errorCode()!=JSOCKERR_graceful_close)
    4856. 

  4856.                 EXCLOG(e,"CSingletonSocketConnection close");
    4857. 

  4857.             e->Release();
    4858. 

  4858.         }
    4859. 

  4859.     }
    4860. 

  4860. 

  4861.     bool connect(unsigned timeoutms)
    4862. 

  4862.     {
    4863. 

  4863.         CriticalBlock block(crit);
    4864. 

  4864.         if (cancelling) 
    4865. 

  4865.             state = Scancelled;
    4866. 

  4866.         if (state==Scancelled)
    4867. 

  4867.             return false;
    4868. 

  4868.         assertex(!sock);
    4869. 

  4869.         ISocket *newsock=NULL;
    4870. 

  4870.         state = Sconnect;
    4871. 

  4871.         unsigned start = 0;
    4872. 

  4872.         if (timeoutms!=(unsigned)INFINITE)
    4873. 

  4873.             start = msTick();
    4874. 

  4874.         while (state==Sconnect) {
    4875. 

  4875.             try {
    4876. 

  4876.                 CriticalUnblock unblock(crit);
    4877. 

  4877.                 newsock = ISocket::connect_wait(ep,1000*60*4);
    4878. 

  4878.                 break;
    4879. 

  4879.             }
    4880. 

  4880.             catch (IException * e) {
    4881. 

  4881.                 if ((e->errorCode()==JSOCKERR_timeout_expired)||(e->errorCode()==JSOCKERR_connection_failed)) {
    4882. 

  4882.                     e->Release();
    4883. 

  4883.                     if ((state==Sconnect)&&(timeoutms!=(unsigned)INFINITE)&&(msTick()-start>timeoutms)) {
    4884. 

  4884.                         state = Snone;
    4885. 

  4885.                         return false;
    4886. 

  4886.                     }
    4887. 

  4887.                 }
    4888. 

  4888.                 else {
    4889. 

  4889.                     state = Scancelled;
    4890. 

  4890.                     EXCLOG(e,"CSingletonSocketConnection::connect");
    4891. 

  4891.                     e->Release();
    4892. 

  4892.                     return false;
    4893. 

  4893.                 }
    4894. 

  4894.             }
    4895. 

  4895.         }   
    4896. 

  4896.         if (state!=Sconnect) {
    4897. 

  4897.             ::Release(newsock);
    4898. 

  4898.             newsock = NULL;
    4899. 

  4899.         }
    4900. 

  4900.         if (!newsock) {
    4901. 

  4901.             state = Scancelled;
    4902. 

  4902.             return false;
    4903. 

  4903.         }
    4904. 

  4904.         sock.setown(newsock);
    4905. 

  4905.         return true;
    4906. 

  4906.     }
    4907. 

  4907. 

  4908.     bool send(MemoryBuffer &mb)
    4909. 

  4909.     {
    4910. 

  4910.         CriticalBlock block(crit);
    4911. 

  4911.         if (cancelling) 
    4912. 

  4912.             state = Scancelled;
    4913. 

  4913.         if (state==Scancelled)
    4914. 

  4914.             return false;
    4915. 

  4915.         assertex(sock);
    4916. 

  4916.         state = Srecv;
    4917. 

  4917.         try {
    4918. 

  4918.             CriticalUnblock unblock(crit);
    4919. 

  4919.             writeBuffer(sock,mb);
    4920. 

  4920.         }
    4921. 

  4921.         catch (IException * e) {
    4922. 

  4922.             state = Scancelled;
    4923. 

  4923.             EXCLOG(e,"CSingletonSocketConnection::send");
    4924. 

  4924.             e->Release();
    4925. 

  4925.             return false;
    4926. 

  4926.         }
    4927. 

  4927.         state = Snone;
    4928. 

  4928.         return true;
    4929. 

  4929.     }
    4930. 

  4930. 

  4931.     unsigned short setRandomPort(unsigned short base, unsigned num)
    4932. 

  4932.     {
    4933. 

  4933.         loop {
    4934. 

  4934.             try {
    4935. 

  4935.                 ep.port = base+(unsigned short)(getRandom()%num);
    4936. 

  4936.                 listensock.setown(ISocket::create(ep.port));
    4937. 

  4937.                 return ep.port;
    4938. 

  4938.             }
    4939. 

  4939.             catch (IException *e) {
    4940. 

  4940.                 if (e->errorCode()!=JSOCKERR_port_in_use) {
    4941. 

  4941.                     state = Scancelled;
    4942. 

  4942.                     EXCLOG(e,"CSingletonSocketConnection::setRandomPort");
    4943. 

  4943.                     e->Release();
    4944. 

  4944.                     break;
    4945. 

  4945.                 }
    4946. 

  4946.                 e->Release();
    4947. 

  4947.             }
    4948. 

  4948.         }
    4949. 

  4949.         return 0;
    4950. 

  4950.     }
    4951. 

  4951. 

  4952. 

  4953.     bool accept(unsigned timeoutms)
    4954. 

  4954.     {
    4955. 

  4955.         CriticalBlock block(crit);
    4956. 

  4956.         if (cancelling) 
    4957. 

  4957.             state = Scancelled;
    4958. 

  4958.         if (state==Scancelled)
    4959. 

  4959.             return false;
    4960. 

  4960.         if (!sock) {
    4961. 

  4961.             ISocket *newsock=NULL;
    4962. 

  4962.             state = Saccept;
    4963. 

  4963.             loop {
    4964. 

  4964.                 try {
    4965. 

  4965.                     { 
    4966. 

  4966.                         CriticalUnblock unblock(crit);
    4967. 

  4967.                         if (!listensock)
    4968. 

  4968.                             listensock.setown(ISocket::create(ep.port));
    4969. 

  4969.                         if ((timeoutms!=(unsigned)INFINITE)&&(!listensock->wait_read(timeoutms))) {
    4970. 

  4970.                             state = Snone;
    4971. 

  4971.                             return false;
    4972. 

  4972.                         }
    4973. 

  4973.                     }
    4974. 

  4974.                     if (cancelling) 
    4975. 

  4975.                         state = Scancelled;
    4976. 

  4976.                     if (state==Scancelled)
    4977. 

  4977.                         return false;
    4978. 

  4978.                     { 
    4979. 

  4979.                         CriticalUnblock unblock(crit);
    4980. 

  4980.                         newsock=listensock->accept(true);
    4981. 

  4981.                         break;
    4982. 

  4982.                     }
    4983. 

  4983.                 }
    4984. 

  4984.                 catch (IException *e) {
    4985. 

  4985.                     if (e->errorCode()==JSOCKERR_graceful_close) 
    4986. 

  4986.                         PROGLOG("CSingletonSocketConnection: Closed socket on accept - retrying...");
    4987. 

  4987.                     else {
    4988. 

  4988.                         state = Scancelled;
    4989. 

  4989.                         EXCLOG(e,"CSingletonSocketConnection::accept");
    4990. 

  4990.                         e->Release();
    4991. 

  4991.                         break;
    4992. 

  4992.                     }
    4993. 

  4993.                     e->Release();
    4994. 

  4994.                 }
    4995. 

  4995.             }
    4996. 

  4996.             if (state!=Saccept) {
    4997. 

  4997.                 ::Release(newsock);
    4998. 

  4998.                 newsock = NULL;
    4999. 

  4999.             }
    5000. 

  5000.             if (!newsock) {
    5001. 

  5001.                 state = Scancelled;
    5002. 

  5002.                 return false;
    5003. 

  5003.             }
    5004. 

  5004.             sock.setown(newsock);
    5005. 

  5005.         }
    5006. 

  5006.         return true;
    5007. 

  5007.     }
    5008. 

  5008. 

  5009.     bool recv(MemoryBuffer &mb, unsigned timeoutms)
    5010. 

  5010.     {
    5011. 

  5011.         CriticalBlock block(crit);
    5012. 

  5012.         if (cancelling) 
    5013. 

  5013.             state = Scancelled;
    5014. 

  5014.         if (state==Scancelled)
    5015. 

  5015.             return false;
    5016. 

  5016.         assertex(sock);
    5017. 

  5017.         state = Srecv;
    5018. 

  5018.         try {
    5019. 

  5019.             CriticalUnblock unblock(crit);
    5020. 

  5020.             readBuffer(sock,mb,timeoutms);
    5021. 

  5021.         }
    5022. 

  5022.         catch (IException *e) {
    5023. 

  5023.             if (e->errorCode()==JSOCKERR_timeout_expired)
    5024. 

  5024.                 state = Snone;
    5025. 

  5025.             else {
    5026. 

  5026.                 state = Scancelled;
    5027. 

  5027.                 if (e->errorCode()!=JSOCKERR_graceful_close)
    5028. 

  5028.                     EXCLOG(e,"CSingletonSocketConnection::recv");
    5029. 

  5029.             }
    5030. 

  5030.             e->Release();
    5031. 

  5031.             return false;
    5032. 

  5032.         }
    5033. 

  5033.         state = Snone;
    5034. 

  5034.         return true;
    5035. 

  5035.     }
    5036. 

  5036. 

  5037.     virtual void cancel()
    5038. 

  5038.     {
    5039. 

  5039.         CriticalBlock block(crit);
    5040. 

  5040.         while (state!=Scancelled) {
    5041. 

  5041.             cancelling = true;
    5042. 

  5042.             try {
    5043. 

  5043.                 switch (state) {
    5044. 

  5044.                 case Saccept:
    5045. 

  5045.                     {
    5046. 

  5046.                         if (listensock)
    5047. 

  5047.                             listensock->cancel_accept();
    5048. 

  5048.                     }
    5049. 

  5049.                     break;
    5050. 

  5050.                 case Sconnect:
    5051. 

  5051.                     // wait for timeout
    5052. 

  5052.                     break;
    5053. 

  5053.                 case Srecv:
    5054. 

  5054.                     {
    5055. 

  5055.                         if (sock)
    5056. 

  5056.                             sock->close();
    5057. 

  5057.                     }
    5058. 

  5058.                     break;
    5059. 

  5059.                 case Ssend:
    5060. 

  5060.                     // wait for finished
    5061. 

  5061.                     break;
    5062. 

  5062.                 default:
    5063. 

  5063.                     state = Scancelled;
    5064. 

  5064.                     break;
    5065. 

  5065.                 }
    5066. 

  5066.             }
    5067. 

  5067.             catch (IException *e) {
    5068. 

  5068.                 EXCLOG(e,"CSingletonSocketConnection::cancel");
    5069. 

  5069.                 e->Release();
    5070. 

  5070.             }
    5071. 

  5071.             {
    5072. 

  5072.                 CriticalUnblock unblock(crit);
    5073. 

  5073.                 Sleep(1000);
    5074. 

  5074.             }
    5075. 

  5075.         }
    5076. 

  5076.     }
    5077. 

  5077. };
    5078. 

  5078. 

  5079.     
    5080. 

  5080. IConversation *createSingletonSocketConnection(unsigned short port,SocketEndpoint *_ep)
    5081. 

  5081. {
    5082. 

  5082.     SocketEndpoint ep;
    5083. 

  5083.     if (_ep)
    5084. 

  5084.         ep = *_ep;
    5085. 

  5085.     if (port)
    5086. 

  5086.         ep.port = port;
    5087. 

  5087.     return new CSingletonSocketConnection(ep);
    5088. 

  5088. }
    5089. 

  5089. 

  5090. 

  5091. // interface for reading from multiple sockets using the BF_SYNC_TRANSFER_PUSH protocol 
    5092. 

  5092. class CSocketBufferReader: public CInterface, implements ISocketBufferReader
    5093. 

  5093. {
    5094. 

  5094.     class SocketElem: public CInterface, implements ISocketSelectNotify
    5095. 

  5095.     {
    5096. 

  5096.         CSocketBufferReader *parent;
    5097. 

  5097.         unsigned num;           // top bit used for ready
    5098. 

  5098.         MemoryAttr blk;
    5099. 

  5099.         CriticalSection sect;
    5100. 

  5100.         Linked<ISocket> sock;
    5101. 

  5101.         bool active;
    5102. 

  5102.         bool pending;
    5103. 

  5103.     public:
    5104. 

  5104.         IMPLEMENT_IINTERFACE;
    5105. 

  5105.         void init(CSocketBufferReader *_parent,ISocket *_sock,unsigned _n)
    5106. 

  5106.         {
    5107. 

  5107.             parent = _parent;
    5108. 

  5108.             num = _n;
    5109. 

  5109.             sock.set(_sock);
    5110. 

  5110.             active = true;
    5111. 

  5111.             pending = false;            
    5112. 

  5112.         }
    5113. 

  5113. 

  5114.         virtual bool notifySelected(ISocket *socket,unsigned selected)
    5115. 

  5115.         {
    5116. 

  5116.             assertex(sock==socket);
    5117. 

  5117.             {
    5118. 

  5118.                 CriticalBlock block(sect);
    5119. 

  5119.                 if (pending) {
    5120. 

  5120.                     active = false;
    5121. 

  5121.                     parent->remove(sock);  
    5122. 

  5122.                     return false;
    5123. 

  5123.                 }
    5124. 

  5124.                 pending = true;
    5125. 

  5125.                 unsigned t1=usTick();
    5126. 

  5126.                 size32_t sz = sock->receive_block_size();
    5127. 

  5127.                 unsigned t2=usTick();
    5128. 

  5128.                 if (sz)
    5129. 

  5129.                     sock->receive_block(blk.allocate(sz),sz);
    5130. 

  5130.                 else
    5131. 

  5131.                     parent->remove(sock);  
    5132. 

  5132.                 unsigned t3=usTick();
    5133. 

  5133.                 if (t3-t1>60*1000000)
    5134. 

  5134.                     PROGLOG("CSocketBufferReader(%d): slow receive_block (%d,%d) sz=%d",num,t2-t1,t3-t2,sz);
    5135. 

  5135.             }
    5136. 

  5136.             parent->enqueue(this); // nb outside sect critical block
    5137. 

  5137.             return false;   // always return false
    5138. 

  5138.         }
    5139. 

  5139.         unsigned get(MemoryBuffer &mb)
    5140. 

  5140.         {
    5141. 

  5141.             CriticalBlock block(sect);
    5142. 

  5142.             assertex(pending);
    5143. 

  5143.             size32_t sz = blk.length();
    5144. 

  5144.             if (sz)
    5145. 

  5145.                 mb.setBuffer(sz,blk.detach(),true);
    5146. 

  5146.             pending = false;
    5147. 

  5147.             if (!active) {
    5148. 

  5148.                 active = true;
    5149. 

  5149.                 parent->add(*this);  
    5150. 

  5150.             }
    5151. 

  5151.             return num;
    5152. 

  5152.         }
    5153. 

  5153.         size32_t size()
    5154. 

  5154.         {
    5155. 

  5155.             return blk.length();
    5156. 

  5156.         }
    5157. 

  5157.         ISocket *getSocket() { return sock; }
    5158. 

  5158.     } *elems;
    5159. 

  5159.     SimpleInterThreadQueueOf<SocketElem, false> readyq;
    5160. 

  5160.     Owned<ISocketSelectHandler> selecthandler;
    5161. 

  5161. 

  5162.     size32_t buffersize;
    5163. 

  5163.     size32_t buffermax;
    5164. 

  5164.     unsigned bufferwaiting;
    5165. 

  5165.     CriticalSection buffersect;
    5166. 

  5166.     Semaphore buffersem;
    5167. 

  5167.     bool isdone;
    5168. 

  5168. 

  5169. public:
    5170. 

  5170. 

  5171.     IMPLEMENT_IINTERFACE;
    5172. 

  5172.     CSocketBufferReader(const char *trc)
    5173. 

  5173.     {
    5174. 

  5174.         selecthandler.setown(createSocketSelectHandler(trc));
    5175. 

  5175.         elems = NULL;
    5176. 

  5176.     }
    5177. 

  5177.     ~CSocketBufferReader()
    5178. 

  5178.     {
    5179. 

  5179.         delete [] elems;
    5180. 

  5180.     }
    5181. 

  5181.     virtual void init(unsigned num,ISocket **sockets,size32_t _buffermax)
    5182. 

  5182.     {
    5183. 

  5183.         elems = new SocketElem[num];
    5184. 

  5184.         for (unsigned i=0;i<num;i++) {
    5185. 

  5185.             ISocket *sock = sockets[i];
    5186. 

  5186.             if (sock) { // can have gaps
    5187. 

  5187.                 elems[i].init(this,sock,i);
    5188. 

  5188.                 add(elems[i]);
    5189. 

  5189.             }
    5190. 

  5190.         }
    5191. 

  5191.         buffersize = 0;
    5192. 

  5192.         buffermax = _buffermax;
    5193. 

  5193.         bufferwaiting = 0;
    5194. 

  5194.         isdone = false;
    5195. 

  5195.         selecthandler->start();
    5196. 

  5196.     }
    5197. 

  5197.     virtual unsigned get(MemoryBuffer &mb)
    5198. 

  5198.     {
    5199. 

  5199.         SocketElem &e = *readyq.dequeue();
    5200. 

  5200.         CriticalBlock block(buffersect);
    5201. 

  5201.         assertex(buffersize>=e.size());
    5202. 

  5202.         buffersize-=e.size();
    5203. 

  5203.         if (bufferwaiting) {
    5204. 

  5204.             buffersem.signal(bufferwaiting);
    5205. 

  5205.             bufferwaiting = 0;
    5206. 

  5206.         }
    5207. 

  5207.         return e.get(mb);
    5208. 

  5208.     }
    5209. 

  5209.     virtual void done(bool wait)
    5210. 

  5210.     {
    5211. 

  5211.         buffersem.signal(0x10000);
    5212. 

  5212.         isdone = true;
    5213. 

  5213.         selecthandler->stop(wait);  
    5214. 

  5214.         if (wait) {
    5215. 

  5215.             delete [] elems;
    5216. 

  5216.             elems = NULL;
    5217. 

  5217.         }
    5218. 

  5218.     }
    5219. 

  5219. 

  5220.     void enqueue(SocketElem *elem)
    5221. 

  5221.     {
    5222. 

  5222.         if (elem) {
    5223. 

  5223.             CriticalBlock block(buffersect);
    5224. 

  5224.             size32_t sz = elem->size();
    5225. 

  5225.             while ((buffersize>0)&&(sz>0)&&(buffersize+sz>buffermax)) {
    5226. 

  5226.                 if (isdone)
    5227. 

  5227.                     return;
    5228. 

  5228.                 bufferwaiting++;
    5229. 

  5229.                 CriticalUnblock unblock(buffersect);
    5230. 

  5230.                 buffersem.wait();
    5231. 

  5231.             }
    5232. 

  5232.             buffersize += sz;
    5233. 

  5233.         }
    5234. 

  5234.         readyq.enqueue(elem);
    5235. 

  5235.     }
    5236. 

  5236. 

  5237.     void remove(ISocket *sock)
    5238. 

  5238.     {
    5239. 

  5239.         selecthandler->remove(sock);
    5240. 

  5240.     }
    5241. 

  5241. 

  5242.     void add(SocketElem &elem)
    5243. 

  5243.     {
    5244. 

  5244.         selecthandler->add(elem.getSocket(),SELECTMODE_READ,&elem);
    5245. 

  5245.     }
    5246. 

  5246. };
    5247. 

  5247. 

  5248. ISocketBufferReader *createSocketBufferReader(const char *trc)
    5249. 

  5249. {
    5250. 

  5250.     return new CSocketBufferReader(trc);
    5251. 

  5251. }
    5252. 

  5252. 

  5253. 

  5254. extern jlib_decl void markNodeCentral(SocketEndpoint &ep)
    5255. 

  5255. {
    5256. 

  5256. #ifdef CENTRAL_NODE_RANDOM_DELAY
    5257. 

  5257.     CriticalBlock block(CSocket::crit);
    5258. 

  5258.     CentralNodeArray.append(ep);
    5259. 

  5259. #endif
    5260. 

  5260. }
    5261. 

  5261. 

  5262. 

  5263. static CSocket *prepareSocket(unsigned idx,const SocketEndpoint &ep, ISocketConnectNotify &inotify)
    5264. 

  5264. {
    5265. 

  5265.     Owned<CSocket> sock = new CSocket(ep,sm_tcp,NULL);
    5266. 

  5266.     int err = sock->pre_connect(false);
    5267. 

  5267.     if ((err == EINPROGRESS)||(err == EWOULDBLOCK)) 
    5268. 

  5268.         return sock.getClear();
    5269. 

  5269.     if (err==0) {
    5270. 

  5270.         int err = sock->post_connect();
    5271. 

  5271.         if (err==0) 
    5272. 

  5272.             inotify.connected(idx,ep,sock);
    5273. 

  5273.         else {
    5274. 

  5274.             sock->errclose();
    5275. 

  5275.             inotify.failed(idx,ep,err);
    5276. 

  5276.         }
    5277. 

  5277.     }
    5278. 

  5278.     else
    5279. 

  5279.         inotify.failed(idx,ep,err);
    5280. 

  5280.     return NULL;
    5281. 

  5281. }
    5282. 

  5282. 

  5283. void multiConnect(const SocketEndpointArray &eps,ISocketConnectNotify &inotify,unsigned timeout)
    5284. 

  5284. {
    5285. 

  5285.     class SocketElem: public CInterface, implements ISocketSelectNotify
    5286. 

  5286.     {
    5287. 

  5287.         CriticalSection *sect;
    5288. 

  5288.         ISocketSelectHandler *handler;
    5289. 

  5289.         unsigned *remaining;
    5290. 

  5290.         Semaphore *notifysem;
    5291. 

  5291.         ISocketConnectNotify *inotify;
    5292. 

  5292.     public:
    5293. 

  5293.         Owned<CSocket> sock;
    5294. 

  5294.         SocketEndpoint ep;
    5295. 

  5295.         unsigned idx;
    5296. 

  5296.         IMPLEMENT_IINTERFACE;
    5297. 

  5297.         void init(CSocket *_sock,unsigned _idx,SocketEndpoint &_ep,CriticalSection *_sect,ISocketSelectHandler *_handler,ISocketConnectNotify *_inotify, unsigned *_remaining, Semaphore *_notifysem)
    5298. 

  5298.         {
    5299. 

  5299.             ep = _ep;
    5300. 

  5300.             idx = _idx;
    5301. 

  5301.             inotify = _inotify;
    5302. 

  5302.             sock.setown(_sock),
    5303. 

  5303.             sect = _sect;
    5304. 

  5304.             handler = _handler;
    5305. 

  5305.             remaining = _remaining;
    5306. 

  5306.             notifysem = _notifysem;
    5307. 

  5307.         }
    5308. 

  5308. 

  5309.         virtual bool notifySelected(ISocket *socket,unsigned selected)
    5310. 

  5310.         {
    5311. 

  5311.             CriticalBlock block(*sect);
    5312. 

  5312.             handler->remove(socket);  
    5313. 

  5313.             int err = sock->post_connect();
    5314. 

  5314.             CSocket *newsock = NULL;
    5315. 

  5315.             {
    5316. 

  5316.                 CriticalUnblock unblock(*sect); // up to caller to cope with multithread
    5317. 

  5317.                 if (err==0) 
    5318. 

  5318.                     inotify->connected(idx,ep,sock);
    5319. 

  5319.                 else if ((err==ETIMEDOUT)||(err==ECONNREFUSED))  { 
    5320. 

  5320.                          // don't give up so easily (maybe listener not yet started (i.e. racing))
    5321. 

  5321.                     newsock = prepareSocket(idx,ep,*inotify);
    5322. 

  5322.                     Sleep(100); // not very nice but without this would just loop 
    5323. 

  5323.                 }
    5324. 

  5324.                 else 
    5325. 

  5325.                     inotify->failed(idx,ep,err);
    5326. 

  5326.             }
    5327. 

  5327.             if (newsock) {
    5328. 

  5328.                 sock.setown(newsock);
    5329. 

  5329.                 handler->add(sock,SELECTMODE_WRITE|SELECTMODE_EXCEPT,this);
    5330. 

  5330.             }
    5331. 

  5331.             else {
    5332. 

  5332.                 sock.clear();
    5333. 

  5333.                 (*remaining)--;
    5334. 

  5334.                 notifysem->signal();
    5335. 

  5335.             }
    5336. 

  5336.             return false;
    5337. 

  5337.         }
    5338. 

  5338.     } *elems;
    5339. 

  5339.     unsigned n = eps.ordinality();
    5340. 

  5340.     unsigned remaining = n;
    5341. 

  5341.     if (!n)
    5342. 

  5342.         return;
    5343. 

  5343.     elems = new SocketElem[n];
    5344. 

  5344.     unsigned i;
    5345. 

  5345.     CriticalSection sect;
    5346. 

  5346.     Semaphore notifysem;
    5347. 

  5347.     Owned<ISocketSelectHandler> selecthandler = createSocketSelectHandler(
    5348. 

  5348. #ifdef _DEBUG
    5349. 

  5349.         "multiConnect"
    5350. 

  5350. #else
    5351. 

  5351.         NULL
    5352. 

  5352. #endif
    5353. 

  5353.     );
    5354. 

  5354. 

  5355.     StringBuffer name;
    5356. 

  5356.     for (i=0;i<n;i++) {
    5357. 

  5357.         CSocket* sock = prepareSocket(i,eps.item(i),inotify);
    5358. 

  5358.         if (sock) {
    5359. 

  5359.             elems[i].init(sock,i,eps.item(i),&sect,selecthandler,&inotify,&remaining,&notifysem);
    5360. 

  5360.             selecthandler->add(sock,SELECTMODE_WRITE|SELECTMODE_EXCEPT,&elems[i]);
    5361. 

  5361.         }           
    5362. 

  5362.         else 
    5363. 

  5363.             remaining--;
    5364. 

  5364.     }
    5365. 

  5365.     if (remaining) {
    5366. 

  5366.         unsigned lastremaining=remaining;
    5367. 

  5367.         selecthandler->start();
    5368. 

  5368.         loop {
    5369. 

  5369.             bool to=!notifysem.wait(timeout);
    5370. 

  5370.             {
    5371. 

  5371.                 CriticalBlock block(sect);
    5372. 

  5372.                 if (remaining==0)
    5373. 

  5373.                     break;
    5374. 

  5374.                 if (to&&(remaining==lastremaining))
    5375. 

  5375.                     break; // nothing happened recently
    5376. 

  5376.                 lastremaining = remaining;
    5377. 

  5377.             }
    5378. 

  5378.         }
    5379. 

  5379.         selecthandler->stop(true);  
    5380. 

  5380.     }
    5381. 

  5381.     selecthandler.clear();
    5382. 

  5382.     if (remaining) {
    5383. 

  5383.         for (unsigned j=0;j<n;j++) {  // mop up timeouts
    5384. 

  5384.             SocketElem &elem = elems[j];
    5385. 

  5385.             if (elem.sock.get())  {
    5386. 

  5386.                 elem.sock.clear();
    5387. 

  5387.                 inotify.failed(j,elem.ep,-1);
    5388. 

  5388.                 remaining--;
    5389. 

  5389.                 if (remaining==0)
    5390. 

  5390.                     break;
    5391. 

  5391.             }
    5392. 

  5392.         }
    5393. 

  5393.     }
    5394. 

  5394.     delete [] elems;
    5395. 

  5395. }
    5396. 

  5396. 

  5397. void multiConnect(const SocketEndpointArray &eps, PointerIArrayOf<ISocket> &retsockets,unsigned timeout)
    5398. 

  5398. {
    5399. 

  5399.     unsigned n = eps.ordinality();
    5400. 

  5400.     if (n==0)
    5401. 

  5401.         return;
    5402. 

  5402.     if (n==1) { // no need for multi
    5403. 

  5403.         ISocket *sock = NULL;
    5404. 

  5404.         try {
    5405. 

  5405.             sock = ISocket::connect_timeout(eps.item(0),timeout);
    5406. 

  5406.         }
    5407. 

  5407.         catch (IException *e) { // ignore error just append NULL
    5408. 

  5408.             sock = NULL;
    5409. 

  5409.             e->Release();
    5410. 

  5410.         }
    5411. 

  5411.         retsockets.append(sock);
    5412. 

  5412.         return;
    5413. 

  5413.     }   
    5414. 

  5414.     while (retsockets.ordinality()<n)
    5415. 

  5415.         retsockets.append(NULL);
    5416. 

  5416.     CriticalSection sect;
    5417. 

  5417.     class cNotify: implements ISocketConnectNotify
    5418. 

  5418.     {
    5419. 

  5419.         CriticalSection &sect;
    5420. 

  5420.         PointerIArrayOf<ISocket> &retsockets;
    5421. 

  5421.     public:
    5422. 

  5422.         cNotify(PointerIArrayOf<ISocket> &_retsockets,CriticalSection &_sect)
    5423. 

  5423.             : retsockets(_retsockets),sect(_sect)
    5424. 

  5424.         {
    5425. 

  5425.         }
    5426. 

  5426.         
    5427. 

  5427.         void connected(unsigned idx,const SocketEndpoint &ep,ISocket *sock)
    5428. 

  5428.         {
    5429. 

  5429.             CriticalBlock block(sect);
    5430. 

  5430.             assertex(idx<retsockets.ordinality());
    5431. 

  5431.             sock->Link();
    5432. 

  5432.             retsockets.replace(sock,idx);
    5433. 

  5433.         }
    5434. 

  5434.         void failed(unsigned idx,const SocketEndpoint &ep,int err)
    5435. 

  5435.         {
    5436. 

  5436.             StringBuffer s;
    5437. 

  5437.             PROGLOG("multiConnect failed to %s with %d",ep.getUrlStr(s).str(),err);
    5438. 

  5438.         }
    5439. 

  5439.     } notify(retsockets,sect);
    5440. 

  5440.     multiConnect(eps,notify,timeout);
    5441. 

  5441. 

  5442. }
    5443. 

  5443. 

  5444. inline void flushText(StringBuffer &text,unsigned short port,unsigned &rep,unsigned &range) 
    5445. 

  5445. {
    5446. 

  5446.     if (rep) {
    5447. 

  5447.         text.append('*').append(rep+1);
    5448. 

  5448.         rep = 0;
    5449. 

  5449.     }
    5450. 

  5450.     else if (range) {
    5451. 

  5451.         text.append('-').append(range);
    5452. 

  5452.         range = 0;
    5453. 

  5453.     }
    5454. 

  5454.     if (port)
    5455. 

  5455.         text.append(':').append(port);
    5456. 

  5456. }
    5457. 

  5457. 

  5458. 

  5459. 

  5460. StringBuffer &SocketEndpointArray::getText(StringBuffer &text)
    5461. 

  5461. {
    5462. 

  5462.     unsigned count = ordinality();
    5463. 

  5463.     if (!count)
    5464. 

  5464.         return text;
    5465. 

  5465.     if (count==1)
    5466. 

  5466.         return item(0).getUrlStr(text);
    5467. 

  5467.     byte lastip[4];
    5468. 

  5468.     const SocketEndpoint &first = item(0);
    5469. 

  5469.     bool lastis4 = first.getNetAddress(sizeof(lastip),&lastip)==sizeof(lastip);
    5470. 

  5470.     unsigned short lastport = first.port;
    5471. 

  5471.     first.getIpText(text);
    5472. 

  5472.     unsigned rep=0;
    5473. 

  5473.     unsigned range=0;
    5474. 

  5474.     for (unsigned i=1;i<count;i++) {
    5475. 

  5475.         byte ip[4];
    5476. 

  5476.         const SocketEndpoint &ep = item(i);
    5477. 

  5477.         bool is4 = ep.getNetAddress(sizeof(ip),&ip)==sizeof(ip);
    5478. 

  5478.         if (!lastis4||!is4) {
    5479. 

  5479.             flushText(text,lastport,rep,range);
    5480. 

  5480.             text.append(',');
    5481. 

  5481.             ep.getIpText(text);
    5482. 

  5482.         }
    5483. 

  5483.         else { // try and shorten
    5484. 

  5484.             unsigned j;
    5485. 

  5485.             for (j=0;j<4;j++)
    5486. 

  5486.                 if (ip[j]!=lastip[j])
    5487. 

  5487.                     break;
    5488. 

  5488.             if (ep.port==lastport) {
    5489. 

  5489.                 if (j==4) {
    5490. 

  5490.                     if (range)  // cant have range and rep
    5491. 

  5491.                         j--;  // pretend only 3 matched
    5492. 

  5492.                     else {
    5493. 

  5493.                         rep++;
    5494. 

  5494.                         continue;
    5495. 

  5495.                     }
    5496. 

  5496.                 }
    5497. 

  5497.                 else if ((j==3)&&(lastip[3]+1==ip[3])&&(rep==0)) {
    5498. 

  5498.                     range = ip[3];
    5499. 

  5499.                     lastip[3] = (byte)range;
    5500. 

  5500.                     continue;
    5501. 

  5501.                 }
    5502. 

  5502.             }
    5503. 

  5503.             flushText(text,lastport,rep,range); 
    5504. 

  5504.             // output diff
    5505. 

  5505.             text.append(',');
    5506. 

  5506.             if (j==4)
    5507. 

  5507.                 j--;
    5508. 

  5508.             for (unsigned k=j;k<4;k++) {
    5509. 

  5509.                 if (k>j)
    5510. 

  5510.                     text.append('.');
    5511. 

  5511.                 text.append((int)ip[k]);
    5512. 

  5512.             }
    5513. 

  5513.         }
    5514. 

  5514.         memcpy(&lastip,&ip,sizeof(lastip));
    5515. 

  5515.         lastis4 = is4;
    5516. 

  5516.         lastport = ep.port;
    5517. 

  5517.     }
    5518. 

  5518.     flushText(text,lastport,rep,range);
    5519. 

  5519.     return text;
    5520. 

  5520. }
    5521. 

  5521. 

  5522. inline const char *getnum(const char *s,unsigned &n)
    5523. 

  5523. {
    5524. 

  5524.     n = 0;
    5525. 

  5525.     while (isdigit(*s)) {
    5526. 

  5526.         n = n*10+(*s-'0');
    5527. 

  5527.         s++;
    5528. 

  5528.     }
    5529. 

  5529.     return s;
    5530. 

  5530. }
    5531. 

  5531. 

  5532. inline bool appendv4range(SocketEndpointArray *array,char *str,SocketEndpoint &ep, unsigned defport)
    5533. 

  5533. {
    5534. 

  5534.     char *s = str;
    5535. 

  5535.     unsigned dc = 0;
    5536. 

  5536.     unsigned port = defport;
    5537. 

  5537.     unsigned rng = 0;
    5538. 

  5538.     unsigned rep = 1;
    5539. 

  5539.     bool notip = false;
    5540. 

  5540.     while (*s) {
    5541. 

  5541.         if (*s=='.') {
    5542. 

  5542.             dc++;
    5543. 

  5543.             s++;
    5544. 

  5544.         }
    5545. 

  5545.         else if (*s==':') {
    5546. 

  5546.             *s = 0;
    5547. 

  5547.             s = (char *)getnum(s+1,port);
    5548. 

  5548.         }
    5549. 

  5549.         else if (*s=='-') {
    5550. 

  5550.             *s = 0;
    5551. 

  5551.             s = (char *)getnum(s+1,rng);
    5552. 

  5552.         }
    5553. 

  5553.         else if (*s=='*') {
    5554. 

  5554.             *s = 0;
    5555. 

  5555.             s = (char *)getnum(s+1,rep);
    5556. 

  5556.         }
    5557. 

  5557.         else {
    5558. 

  5558.             if (!isdigit(*s))
    5559. 

  5559.                 notip = true;
    5560. 

  5560.             s++;
    5561. 

  5561.         }
    5562. 

  5562.     }
    5563. 

  5563.     ep.port = port;
    5564. 

  5564.     if (*str) {
    5565. 

  5565.         if (!notip&&((dc<3)&&((dc!=1)||(strlen(str)!=1)))) {
    5566. 

  5566.             if (!ep.isIp4()) {
    5567. 

  5567.                 return false;
    5568. 

  5568.             }
    5569. 

  5569.             StringBuffer tmp;
    5570. 

  5570.             ep.getIpText(tmp);
    5571. 

  5571.             size32_t l = tmp.length();
    5572. 

  5572.             dc++;
    5573. 

  5573.             loop { 
    5574. 

  5574.                 if (tmp.length()==0)
    5575. 

  5575.                     return false;
    5576. 

  5576.                 if (tmp.charAt(tmp.length()-1)=='.')
    5577. 

  5577.                     if (--dc==0)
    5578. 

  5578.                         break;
    5579. 

  5579.                 tmp.setLength(tmp.length()-1);
    5580. 

  5580.             }
    5581. 

  5581.             tmp.append(str);
    5582. 

  5582.             if (rng) {
    5583. 

  5583.                 tmp.appendf("-%d",rng);
    5584. 

  5584.                 rep = ep.ipsetrange(tmp.str());
    5585. 

  5585.             }
    5586. 

  5586.             else
    5587. 

  5587.                 ep.ipset(tmp.str());
    5588. 

  5588.         }
    5589. 

  5589.         else if (rng) { // not nice as have to add back range (must be better way - maybe ipincrementto) TBD
    5590. 

  5590.             StringBuffer tmp;
    5591. 

  5591.             tmp.appendf("%s-%d",str,rng);
    5592. 

  5592.             rep = ep.ipsetrange(tmp.str());
    5593. 

  5593.         }
    5594. 

  5594.         else if (*str)
    5595. 

  5595.             ep.ipset(str);
    5596. 

  5596.         if (ep.isNull())
    5597. 

  5597.             ep.port = 0;
    5598. 

  5598.         for (unsigned i=0;i<rep;i++) {
    5599. 

  5599.             array->append(ep);
    5600. 

  5600.             if (rng)
    5601. 

  5601.                 ep.ipincrement(1);
    5602. 

  5602.         }
    5603. 

  5603.     }
    5604. 

  5604.     else  {// just a port change
    5605. 

  5605.         if (ep.isNull())        // avoid null values with ports
    5606. 

  5606.             ep.port = 0;
    5607. 

  5607.         array->append(ep);
    5608. 

  5608.     }
    5609. 

  5609.     return true;
    5610. 

  5610. }
    5611. 

  5611. 

  5612. void SocketEndpointArray::fromText(const char *text,unsigned defport) 
    5613. 

  5613. {
    5614. 

  5614.     // this is quite complicated with (mixed) IPv4 and IPv6
    5615. 

  5615.     // only support 'full' IPv6 and no ranges
    5616. 

  5616. 

  5617. 

  5618.     char *str = strdup(text);
    5619. 

  5619.     char *s = str;
    5620. 

  5620.     SocketEndpoint ep;
    5621. 

  5621.     bool eol = false;
    5622. 

  5622.     loop {
    5623. 

  5623.         while (isspace(*s)||(*s==','))
    5624. 

  5624.             s++;
    5625. 

  5625.         if (!*s)
    5626. 

  5626.             break;
    5627. 

  5627.         char *e=s;
    5628. 

  5628.         if (*e=='[') {  // we have a IPv6
    5629. 

  5629.             while (*e&&(*e!=']'))
    5630. 

  5630.                 e++;
    5631. 

  5631.             while ((*e!=',')&&!isspace(*e)) {
    5632. 

  5632.                 if (!*s) {
    5633. 

  5633.                     eol = true;
    5634. 

  5634.                     break;
    5635. 

  5635.                 }
    5636. 

  5636.                 e++;
    5637. 

  5637.             }
    5638. 

  5638.             *e = 0;
    5639. 

  5639.             ep.set(s,defport);
    5640. 

  5640.             if (ep.isNull()) {
    5641. 

  5641.                 // Error TBD
    5642. 

  5642.             }
    5643. 

  5643.             append(ep);
    5644. 

  5644.         }
    5645. 

  5645.         else {
    5646. 

  5646.             bool hascolon = false;
    5647. 

  5647.             bool isv6 = false;
    5648. 

  5648.             do {
    5649. 

  5649.                 if (*e==':') {
    5650. 

  5650.                     if (hascolon)
    5651. 

  5651.                         isv6 = true;
    5652. 

  5652.                     else
    5653. 

  5653.                         hascolon = true;
    5654. 

  5654.                 }
    5655. 

  5655.                 e++;
    5656. 

  5656.                 if (!*e) {
    5657. 

  5657.                     eol = true;
    5658. 

  5658.                     break;
    5659. 

  5659.                 }
    5660. 

  5660.             } while (!isspace(*e)&&(*e!=','));
    5661. 

  5661.             *e = 0;
    5662. 

  5662.             if (isv6) {
    5663. 

  5663.                 ep.set(s,defport);
    5664. 

  5664.                 if (ep.isNull()) {
    5665. 

  5665.                     // Error TBD
    5666. 

  5666.                 }
    5667. 

  5667.                 append(ep);
    5668. 

  5668.             }
    5669. 

  5669.             else {
    5670. 

  5670.                 if (!appendv4range(this,s,ep,defport)) {
    5671. 

  5671.                     // Error TBD
    5672. 

  5672.                 }
    5673. 

  5673.             }
    5674. 

  5674. 

  5675.         }
    5676. 

  5676.         if (eol)
    5677. 

  5677.             break;
    5678. 

  5678.         s = e+1;
    5679. 

  5679.     }
    5680. 

  5680.     free(str);
    5681. 

  5681. }
    5682. 

  5682. 

  5683. 

  5684. bool IpSubNet::set(const char *_net,const char *_mask)
    5685. 

  5685. {
    5686. 

  5686.     if (!_net||!decodeNumericIP(_net,net)) {    // _net NULL means match everything
    5687. 

  5687.         memset(net,0,sizeof(net));
    5688. 

  5688.         memset(mask,0,sizeof(mask));
    5689. 

  5689.         return (_net==NULL);
    5690. 

  5690.     }
    5691. 

  5691.     if (!_mask||!decodeNumericIP(_mask,mask)) { // _mask NULL means match exact
    5692. 

  5692.         memset(mask,0xff,sizeof(mask));
    5693. 

  5693.         return (_mask==NULL);
    5694. 

  5694.     }
    5695. 

  5695.     if (isIp4(net)!=isIp4(mask))
    5696. 

  5696.         return false;
    5697. 

  5697.     for (unsigned j=0;j<4;j++)
    5698. 

  5698.         if (net[j]&~mask[j])
    5699. 

  5699.             return false;
    5700. 

  5700.     return true;
    5701. 

  5701. }
    5702. 

  5702. 

  5703. bool IpSubNet::test(const IpAddress &ip) const
    5704. 

  5704. {
    5705. 

  5705.     unsigned i;
    5706. 

  5706.     if (ip.getNetAddress(sizeof(i),&i)==sizeof(i)) {
    5707. 

  5707.         if (!isIp4(net))
    5708. 

  5708.             return false;
    5709. 

  5709.         return (i&mask[3])==(net[3]&mask[3]);
    5710. 

  5710.     }
    5711. 

  5711.     unsigned na[4];
    5712. 

  5712.     if (ip.getNetAddress(sizeof(na),&na)==sizeof(na)) {
    5713. 

  5713.         for (unsigned j=0;j<4;j++)
    5714. 

  5714.             if ((na[j]&mask[j])!=(net[j]&mask[j]))
    5715. 

  5715.                 return false;
    5716. 

  5716.         return true;
    5717. 

  5717.     }
    5718. 

  5718.     return false;
    5719. 

  5719. }
    5720. 

  5720. 

  5721. StringBuffer IpSubNet::getNetText(StringBuffer &text) const
    5722. 

  5722. {
    5723. 

  5723.     char tmp[INET6_ADDRSTRLEN];
    5724. 

  5724.     const char *res  = ::isIp4(net) ? _inet_ntop(AF_INET, &net[3], tmp, sizeof(tmp))
    5725. 

  5725.                                     : _inet_ntop(AF_INET6, &net, tmp, sizeof(tmp));
    5726. 

  5726.     return text.append(res);
    5727. 

  5727. }
    5728. 

  5728. 

  5729. StringBuffer IpSubNet::getMaskText(StringBuffer &text) const
    5730. 

  5730. {
    5731. 

  5731.     char tmp[INET6_ADDRSTRLEN];
    5732. 

  5732.     // isIp4(net) is correct here
    5733. 

  5733.     const char *res  = ::isIp4(net) ? _inet_ntop(AF_INET, &mask[3], tmp, sizeof(tmp))
    5734. 

  5734.                                     : _inet_ntop(AF_INET6, &mask, tmp, sizeof(tmp));
    5735. 

  5735.     return text.append(res);
    5736. 

  5736. }
    5737. 

  5737. 

  5738. bool IpSubNet::isNull() const
    5739. 

  5739. {
    5740. 

  5740.     for (unsigned i=0;i<4;i++)
    5741. 

  5741.         if (net[i]||mask[i])
    5742. 

  5742.             return false;
    5743. 

  5743.     return true;
    5744. 

  5744. }
    5745. 

  5745. 

  5746. IpSubNet &queryPreferredSubnet()
    5747. 

  5747. {
    5748. 

  5748.     return PreferredSubnet;
    5749. 

  5749. }
    5750. 

  5750. 

  5751. bool setPreferredSubnet(const char *ip,const char *mask)
    5752. 

  5752. {
    5753. 

  5753.     // also resets cached host IP
    5754. 

  5754.     if (PreferredSubnet.set(ip,mask))
    5755. 

  5755.     {
    5756. 

  5756.         if (!cachehostip.isNull()) 
    5757. 

  5757.         {
    5758. 

  5758.             cachehostip.ipset(NULL);
    5759. 

  5759.             queryHostIP();
    5760. 

  5760.         }
    5761. 

  5761.         return true;
    5762. 

  5762.     }
    5763. 

  5763.     else
    5764. 

  5764.         return false;
    5765. 

  5765. }
    5766. 

  5766. 

  5767. StringBuffer lookupHostName(const IpAddress &ip,StringBuffer &ret)
    5768. 

  5768. {
    5769. 

  5769. // not a common routine (no Jlib function!) only support IPv4 initially
    5770. 

  5770.     unsigned ipa;
    5771. 

  5771.     if (ip.getNetAddress(sizeof(ipa),&ipa)==sizeof(ipa)) {
    5772. 

  5772.         struct hostent *phostent = gethostbyaddr( (char *) &ipa, sizeof(ipa), PF_INET);
    5773. 

  5773.         if (phostent)
    5774. 

  5774.             ret.append(phostent->h_name);
    5775. 

  5775.         else
    5776. 

  5776.             ip.getIpText(ret);
    5777. 

  5777.     }
    5778. 

  5778.     else
    5779. 

  5779.         ip.getIpText(ret);
    5780. 

  5780.     return ret;
    5781. 

  5781. }
    5782. 

  5782. 

  5783. struct SocketEndpointHTElem
    5784. 

  5784. {
    5785. 

  5785.     IInterface *ii;
    5786. 

  5786.     SocketEndpoint ep;
    5787. 

  5787.     SocketEndpointHTElem(const SocketEndpoint _ep,IInterface *_ii) { ep.set(_ep); ii = _ii; }
    5788. 

  5788.     ~SocketEndpointHTElem() { ::Release(ii); }
    5789. 

  5789. };
    5790. 

  5790. 

  5791. 

  5792. class jlib_decl CSocketEndpointHashTable : public SuperHashTableOf<SocketEndpointHTElem, SocketEndpoint>, implements ISocketEndpointHashTable
    5793. 

  5793. {
    5794. 

  5794. 

  5795.         
    5796. 

  5796.     virtual void onAdd(void *) {}
    5797. 

  5797.     virtual void onRemove(void *e) { delete (SocketEndpointHTElem *)e; }
    5798. 

  5798.     
    5799. 

  5799.     unsigned getHashFromElement(const void *e) const
    5800. 

  5800.     {
    5801. 

  5801.         return ((const SocketEndpointHTElem *)e)->ep.hash(0);
    5802. 

  5802.     }
    5803. 

  5803.     unsigned getHashFromFindParam(const void *fp) const
    5804. 

  5804.     {
    5805. 

  5805.         return ((const SocketEndpoint *)fp)->hash(0);
    5806. 

  5806.     }
    5807. 

  5807.     const void * getFindParam(const void *p) const
    5808. 

  5808.     {
    5809. 

  5809.         return &((const SocketEndpointHTElem *)p)->ep;
    5810. 

  5810.     }
    5811. 

  5811. 

  5812.     bool matchesFindParam(const void * et, const void *fp, unsigned) const
    5813. 

  5813.     {
    5814. 

  5814.         return ((const SocketEndpointHTElem *)et)->ep.equals(*(SocketEndpoint *)fp);
    5815. 

  5815.     }
    5816. 

  5816. 

  5817.     IMPLEMENT_SUPERHASHTABLEOF_REF_FIND(SocketEndpointHTElem,SocketEndpoint);
    5818. 

  5818.     
    5819. 

  5819. public: 
    5820. 

  5820.     IMPLEMENT_IINTERFACE;
    5821. 

  5821. 

  5822.     CSocketEndpointHashTable() {}
    5823. 

  5823.     ~CSocketEndpointHashTable() { kill(); }
    5824. 

  5824.     
    5825. 

  5825.     void add(const SocketEndpoint &ep, IInterface *i)
    5826. 

  5826.     {
    5827. 

  5827.         SocketEndpointHTElem *e = SuperHashTableOf<SocketEndpointHTElem,SocketEndpoint>::find(&ep);
    5828. 

  5828.         if (e) {
    5829. 

  5829.             ::Release(e->ii);
    5830. 

  5830.             e->ii = i;
    5831. 

  5831.         }
    5832. 

  5832.         else {
    5833. 

  5833.             e = new SocketEndpointHTElem(ep,i);
    5834. 

  5834.             SuperHashTableOf<SocketEndpointHTElem,SocketEndpoint>::add(*e);
    5835. 

  5835.         }
    5836. 

  5836.         
    5837. 

  5837.     }
    5838. 

  5838. 

  5839.     void remove(const SocketEndpoint &ep)
    5840. 

  5840.     {
    5841. 

  5841.         SuperHashTableOf<SocketEndpointHTElem,SocketEndpoint>::remove(&ep);
    5842. 

  5842.     }
    5843. 

  5843. 

  5844.     IInterface *find(const SocketEndpoint &ep)
    5845. 

  5845.     {
    5846. 

  5846.         SocketEndpointHTElem *e = SuperHashTableOf<SocketEndpointHTElem,SocketEndpoint>::find(&ep);
    5847. 

  5847.         if (e) 
    5848. 

  5848.             return e->ii;
    5849. 

  5849.         return NULL;
    5850. 

  5850.     }
    5851. 

  5851.     
    5852. 

  5852. };
    5853. 

  5853. 

  5854. 

  5855. ISocketEndpointHashTable *createSocketEndpointHashTable()
    5856. 

  5856. {
    5857. 

  5857.     CSocketEndpointHashTable *ht = new CSocketEndpointHashTable;
    5858. 

  5858.     return ht;
    5859. 

  5859. }
    5860. 

  5860. 

  5861. 

  5862. class CSocketConnectWait: public CInterface, implements ISocketConnectWait
    5863. 

  5863. {
    5864. 

  5864.     Owned<CSocket> sock;
    5865. 

  5865.     bool done;
    5866. 

  5866.     CTimeMon connecttm;
    5867. 

  5867.     unsigned startt;
    5868. 

  5868.     bool oneshot;
    5869. 

  5869.     bool isopen;    
    5870. 

  5870.     int initerr;
    5871. 

  5871. 

  5872.     void successfulConnect()
    5873. 

  5873.     {
    5874. 

  5874.         STATS.connects++;
    5875. 

  5875.         STATS.connecttime+=usTick()-startt;
    5876. 

  5876. #ifdef _TRACE
    5877. 

  5877.         char peer[256];
    5878. 

  5878.         peer[0] = 'C';
    5879. 

  5879.         peer[1] = '!';
    5880. 

  5880.         strcpy(peer+2,sock->hostname?sock->hostname:"(NULL)");
    5881. 

  5881.         free(sock->tracename);
    5882. 

  5882.         sock->tracename = strdup(peer);
    5883. 

  5883. #endif              
    5884. 

  5884.     }
    5885. 

  5885. 

  5886.     void failedConnect()
    5887. 

  5887.     {
    5888. 

  5888.         STATS.failedconnects++;
    5889. 

  5889.         STATS.failedconnecttime+=usTick()-startt;
    5890. 

  5890.         const char* tracename = sock->tracename;
    5891. 

  5891.         THROWJSOCKEXCEPTION(JSOCKERR_connection_failed);
    5892. 

  5892.     }
    5893. 

  5893. 

  5894. public:
    5895. 

  5895.     IMPLEMENT_IINTERFACE;
    5896. 

  5896. 

  5897.     CSocketConnectWait(SocketEndpoint &ep,unsigned connecttimeoutms)
    5898. 

  5898.         : connecttm(connecttimeoutms)
    5899. 

  5899.     {
    5900. 

  5900.         oneshot = (connecttimeoutms==0); // i.e. as long as one connect takes
    5901. 

  5901.         done = false;
    5902. 

  5902.         startt = usTick();
    5903. 

  5903.         sock.setown(new CSocket(ep,sm_tcp,NULL));
    5904. 

  5904.         isopen = true;
    5905. 

  5905.         initerr = sock->pre_connect(false);
    5906. 

  5906.     }
    5907. 

  5907. 

  5908.     ISocket *wait(unsigned timems)
    5909. 

  5909.     {
    5910. 

  5910.         // this is a bit spagetti due to dual timeouts etc
    5911. 

  5911.         CTimeMon waittm(timems);
    5912. 

  5912.         unsigned refuseddelay = 1;
    5913. 

  5913.         bool waittimedout = false;
    5914. 

  5914.         bool connectimedout = false;
    5915. 

  5915.         do {
    5916. 

  5916.             bool connectdone = false;
    5917. 

  5917.             unsigned remaining;
    5918. 

  5918.             connectimedout = connecttm.timedout(&remaining);
    5919. 

  5919.             unsigned waitremaining;
    5920. 

  5920.             waittimedout = waittm.timedout(&waitremaining);
    5921. 

  5921.             if (oneshot||(waitremaining<remaining))
    5922. 

  5922.                 remaining = waitremaining;
    5923. 

  5923.             int err = 0;
    5924. 

  5924.             if (!isopen||initerr) {
    5925. 

  5925.                 isopen = true;
    5926. 

  5926.                 err = initerr?initerr:sock->pre_connect(false);
    5927. 

  5927.                 initerr = 0;
    5928. 

  5928.                 if ((err == EINPROGRESS)||(err == EWOULDBLOCK))
    5929. 

  5929.                     err = 0; // continue
    5930. 

  5930.                 else {
    5931. 

  5931.                     if (err==0) 
    5932. 

  5932.                         connectdone = true; // done immediately
    5933. 

  5933.                     else if(!oneshot) //  probably ECONNREFUSED but treat all errors same
    5934. 

  5934.                         refused_sleep((waitremaining==remaining)?waittm:connecttm,refuseddelay); // this stops becoming cpu bound
    5935. 

  5935.                 }
    5936. 

  5936.             }
    5937. 

  5937.             if (!connectdone&&(err==0)) {
    5938. 

  5938.                 SOCKET s = sock->sock;
    5939. 

  5939.                 T_FD_SET fds;
    5940. 

  5940.                 struct timeval tv;
    5941. 

  5941.                 XFD_ZERO(&fds);
    5942. 

  5942.                 FD_SET((unsigned)s, &fds);
    5943. 

  5943.                 T_FD_SET except;
    5944. 

  5944.                 XFD_ZERO(&except);
    5945. 

  5945.                 FD_SET((unsigned)s, &except);
    5946. 

  5946.                 tv.tv_sec = remaining / 1000;
    5947. 

  5947.                 tv.tv_usec = (remaining % 1000)*1000;
    5948. 

  5948.                 CHECKSOCKRANGE(s);
    5949. 

  5949.                 int rc = ::select( s + 1, NULL, (fd_set *)&fds, (fd_set *)&except, &tv );
    5950. 

  5950.                 if (rc==0) 
    5951. 

  5951.                     break; // timeout
    5952. 

  5952.                 done = true;
    5953. 

  5953.                 err = 0;
    5954. 

  5954.                 if (rc>0) {
    5955. 

  5955.                     // select succeeded - return error from socket (0 if connected)
    5956. 

  5956.                     socklen_t errlen = sizeof(err);
    5957. 

  5957.                     rc = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *)&err, &errlen); // check for error
    5958. 

  5958.                     if ((rc!=0)&&!err) 
    5959. 

  5959.                         err = ERRNO();  // some implementations of getsockopt duff
    5960. 

  5960.                     if (err&&!oneshot) //  probably ECONNREFUSED but treat all errors same
    5961. 

  5961.                         refused_sleep((waitremaining==remaining)?waittm:connecttm,refuseddelay); // this stops becoming cpu bound
    5962. 

  5962.                 }
    5963. 

  5963.                 else { // select failed
    5964. 

  5964.                     err = ERRNO();
    5965. 

  5965.                     LOGERR(err,2,"CSocketConnectWait ::select");
    5966. 

  5966.                 }
    5967. 

  5967.             }
    5968. 

  5968.             if (err==0) {
    5969. 

  5969.                 err = sock->post_connect();
    5970. 

  5970.                 if (err==0) {
    5971. 

  5971.                     successfulConnect();
    5972. 

  5972.                     return sock.getClear();
    5973. 

  5973.                 }
    5974. 

  5974.             }
    5975. 

  5975.             sock->errclose();
    5976. 

  5976.             isopen = false;
    5977. 

  5977.         } while (!waittimedout&&!oneshot);
    5978. 

  5978.         if (connectimedout) {
    5979. 

  5979.             STATS.failedconnects++;
    5980. 

  5980.             STATS.failedconnecttime+=usTick()-startt;
    5981. 

  5981.             const char* tracename = sock->tracename;
    5982. 

  5982.             THROWJSOCKEXCEPTION(JSOCKERR_connection_failed);
    5983. 

  5983.         }
    5984. 

  5984.         return NULL;
    5985. 

  5985. 

  5986.     }
    5987. 

  5987. 

  5988. };
    5989. 

  5989. 

  5990. ISocketConnectWait *nonBlockingConnect(SocketEndpoint &ep,unsigned connecttimeoutms)
    5991. 

  5991. {
    5992. 

  5992.     return new CSocketConnectWait(ep,connecttimeoutms);
    5993. 

  5993. }
    5994. 

  5994.