net.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:18k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file net.cpp
  3.  * @brief Cross-platform routines for sending and receiving packets.
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "linden_common.h"
  33. #include "net.h"
  34. // system library includes
  35. #include <stdexcept>
  36. #if LL_WINDOWS
  37. #define WIN32_LEAN_AND_MEAN
  38. #include <winsock2.h>
  39. #include <windows.h>
  40. #else
  41. #include <sys/types.h>
  42. #include <sys/socket.h>
  43. #include <netinet/in.h>
  44. #include <arpa/inet.h>
  45. #include <fcntl.h>
  46. #include <errno.h>
  47. #endif
  48. // linden library includes
  49. #include "llerror.h"
  50. #include "llhost.h"
  51. #include "lltimer.h"
  52. #include "indra_constants.h"
  53. // Globals
  54. #if LL_WINDOWS
  55. SOCKADDR_IN stDstAddr;
  56. SOCKADDR_IN stSrcAddr;
  57. SOCKADDR_IN stLclAddr;
  58. static WSADATA stWSAData;
  59. #else
  60. struct sockaddr_in stDstAddr;
  61. struct sockaddr_in stSrcAddr;
  62. struct sockaddr_in stLclAddr;
  63. #if LL_DARWIN
  64. #ifndef _SOCKLEN_T
  65. #define _SOCKLEN_T
  66. typedef int socklen_t;
  67. #endif
  68. #endif
  69. #endif
  70. static U32 gsnReceivingIFAddr = INVALID_HOST_IP_ADDRESS; // Address to which datagram was sent
  71. const char* LOOPBACK_ADDRESS_STRING = "127.0.0.1";
  72. const char* BROADCAST_ADDRESS_STRING = "255.255.255.255";
  73. #if LL_DARWIN
  74. // Mac OS X returns an error when trying to set these to 400000.  Smaller values succeed.
  75. const int SEND_BUFFER_SIZE = 200000;
  76. const int RECEIVE_BUFFER_SIZE = 200000;
  77. #else // LL_DARWIN
  78. const int SEND_BUFFER_SIZE = 400000;
  79. const int RECEIVE_BUFFER_SIZE = 400000;
  80. #endif // LL_DARWIN
  81. // universal functions (cross-platform)
  82. LLHost get_sender()
  83. {
  84. return LLHost(stSrcAddr.sin_addr.s_addr, ntohs(stSrcAddr.sin_port));
  85. }
  86. U32 get_sender_ip(void) 
  87. {
  88. return stSrcAddr.sin_addr.s_addr;
  89. }
  90. U32 get_sender_port() 
  91. {
  92. return ntohs(stSrcAddr.sin_port);
  93. }
  94. LLHost get_receiving_interface()
  95. {
  96. return LLHost(gsnReceivingIFAddr, INVALID_PORT);
  97. }
  98. U32 get_receiving_interface_ip(void)
  99. {
  100. return gsnReceivingIFAddr;
  101. }
  102. const char* u32_to_ip_string(U32 ip)
  103. {
  104. static char buffer[MAXADDRSTR];  /* Flawfinder: ignore */ 
  105. // Convert the IP address into a string
  106. in_addr in;
  107. in.s_addr = ip;
  108. char* result = inet_ntoa(in);
  109. // NULL indicates error in conversion
  110. if (result != NULL)
  111. {
  112. strncpy( buffer, result, MAXADDRSTR );  /* Flawfinder: ignore */ 
  113. buffer[MAXADDRSTR-1] = '';
  114. return buffer;
  115. }
  116. else
  117. {
  118. return "(bad IP addr)";
  119. }
  120. }
  121. // Returns ip_string if successful, NULL if not.  Copies into ip_string
  122. char *u32_to_ip_string(U32 ip, char *ip_string)
  123. {
  124. char *result;
  125. in_addr in;
  126. // Convert the IP address into a string
  127. in.s_addr = ip;
  128. result = inet_ntoa(in);
  129. // NULL indicates error in conversion
  130. if (result != NULL)
  131. {
  132. //the function signature needs to change to pass in the lengfth of first and last.
  133. strcpy(ip_string, result); /*Flawfinder: ignore*/
  134. return ip_string;
  135. }
  136. else
  137. {
  138. return NULL;
  139. }
  140. }
  141. // Wrapper for inet_addr()
  142. U32 ip_string_to_u32(const char* ip_string)
  143. {
  144. // *NOTE: Windows doesn't support inet_aton(), so we are using
  145. // inet_addr(). Unfortunately, INADDR_NONE == INADDR_BROADCAST, so 
  146. // we have to check whether the input is a broadcast address before
  147. // deciding that @ip_string is invalid.
  148. //
  149. // Also, our definition of INVALID_HOST_IP_ADDRESS doesn't allow us to
  150. // use wildcard addresses. -Ambroff
  151. U32 ip = inet_addr(ip_string);
  152. if (ip == INADDR_NONE 
  153.     && strncmp(ip_string, BROADCAST_ADDRESS_STRING, MAXADDRSTR) != 0)
  154. {
  155. llwarns << "ip_string_to_u32() failed, Error: Invalid IP string '" << ip_string << "'" << llendl;
  156. return INVALID_HOST_IP_ADDRESS;
  157. }
  158. return ip;
  159. }
  160. //////////////////////////////////////////////////////////////////////////////////////////
  161. // Windows Versions
  162. //////////////////////////////////////////////////////////////////////////////////////////
  163. #if LL_WINDOWS
  164.  
  165. S32 start_net(S32& socket_out, int& nPort) 
  166. {
  167. // Create socket, make non-blocking
  168.     // Init WinSock 
  169. int nRet;
  170. int hSocket;
  171. int snd_size = SEND_BUFFER_SIZE;
  172. int rec_size = RECEIVE_BUFFER_SIZE;
  173. int buff_size = 4;
  174.  
  175. // Initialize windows specific stuff
  176. if(WSAStartup(0x0202, &stWSAData))
  177. {
  178. S32 err = WSAGetLastError();
  179. WSACleanup();
  180. LL_WARNS("AppInit") << "Windows Sockets initialization failed, err " << err << LL_ENDL;
  181. return 1;
  182. }
  183. // Get a datagram socket
  184.     hSocket = (int)socket(AF_INET, SOCK_DGRAM, 0);
  185.     if (hSocket == INVALID_SOCKET)
  186. {
  187. S32 err = WSAGetLastError();
  188. WSACleanup();
  189. LL_WARNS("AppInit") << "socket() failed, err " << err << LL_ENDL;
  190. return 2;
  191. }
  192. // Name the socket (assign the local port number to receive on)
  193. stLclAddr.sin_family      = AF_INET;
  194. stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  195. stLclAddr.sin_port        = htons(nPort);
  196. S32 attempt_port = nPort;
  197. LL_DEBUGS("AppInit") << "attempting to connect on port " << attempt_port << LL_ENDL;
  198. nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
  199. if (nRet == SOCKET_ERROR)
  200. {
  201. // If we got an address in use error...
  202. if (WSAGetLastError() == WSAEADDRINUSE)
  203. {
  204. // Try all ports from PORT_DISCOVERY_RANGE_MIN to PORT_DISCOVERY_RANGE_MAX
  205. for(attempt_port = PORT_DISCOVERY_RANGE_MIN;
  206. attempt_port <= PORT_DISCOVERY_RANGE_MAX;
  207. attempt_port++)
  208. {
  209. stLclAddr.sin_port = htons(attempt_port);
  210. LL_DEBUGS("AppInit") << "trying port " << attempt_port << LL_ENDL;
  211. nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
  212. if (!(nRet == SOCKET_ERROR && 
  213. WSAGetLastError() == WSAEADDRINUSE))
  214. {
  215. break;
  216. }
  217. }
  218. if (nRet == SOCKET_ERROR)
  219. {
  220. LL_WARNS("AppInit") << "startNet() : Couldn't find available network port." << LL_ENDL;
  221. // Fail gracefully here in release
  222. return 3;
  223. }
  224. }
  225. else
  226. // Some other socket error
  227. {
  228. LL_WARNS("AppInit") << llformat("bind() port: %d failed, Err: %dn", nPort, WSAGetLastError()) << LL_ENDL;
  229. // Fail gracefully in release.
  230. return 4;
  231. }
  232. }
  233. sockaddr_in socket_address;
  234. S32 socket_address_size = sizeof(socket_address);
  235. getsockname(hSocket, (SOCKADDR*) &socket_address, &socket_address_size);
  236. attempt_port = ntohs(socket_address.sin_port);
  237. LL_INFOS("AppInit") << "connected on port " << attempt_port << LL_ENDL;
  238. nPort = attempt_port;
  239. // Set socket to be non-blocking
  240. unsigned long argp = 1;
  241. nRet = ioctlsocket (hSocket, FIONBIO, &argp);
  242. if (nRet == SOCKET_ERROR) 
  243. {
  244. printf("Failed to set socket non-blocking, Err: %dn", 
  245. WSAGetLastError());
  246. }
  247. // set a large receive buffer
  248. nRet = setsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, buff_size);
  249. if (nRet)
  250. {
  251. LL_INFOS("AppInit") << "Can't set receive buffer size!" << LL_ENDL;
  252. }
  253. nRet = setsockopt(hSocket, SOL_SOCKET, SO_SNDBUF, (char *)&snd_size, buff_size);
  254. if (nRet)
  255. {
  256. LL_INFOS("AppInit") << "Can't set send buffer size!" << LL_ENDL;
  257. }
  258. getsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, &buff_size);
  259. getsockopt(hSocket, SOL_SOCKET, SO_SNDBUF, (char *)&snd_size, &buff_size);
  260. LL_DEBUGS("AppInit") << "startNet - receive buffer size : " << rec_size << LL_ENDL;
  261. LL_DEBUGS("AppInit") << "startNet - send buffer size    : " << snd_size << LL_ENDL;
  262. //  Setup a destination address
  263. stDstAddr.sin_family =      AF_INET;
  264. stDstAddr.sin_addr.s_addr = INVALID_HOST_IP_ADDRESS;
  265.     stDstAddr.sin_port =        htons(nPort);
  266. socket_out = hSocket;
  267. return 0;
  268. }
  269. void end_net(S32& socket_out)
  270. {
  271. if (socket_out >= 0)
  272. {
  273. shutdown(socket_out, SD_BOTH);
  274. closesocket(socket_out);
  275. }
  276. WSACleanup();
  277. }
  278. S32 receive_packet(int hSocket, char * receiveBuffer)
  279. {
  280. //  Receives data asynchronously from the socket set by initNet().
  281. //  Returns the number of bytes received into dataReceived, or zero
  282. //  if there is no data received.
  283. int nRet;
  284. int addr_size = sizeof(struct sockaddr_in);
  285. nRet = recvfrom(hSocket, receiveBuffer, NET_BUFFER_SIZE, 0, (struct sockaddr*)&stSrcAddr, &addr_size);
  286. if (nRet == SOCKET_ERROR ) 
  287. {
  288. if (WSAEWOULDBLOCK == WSAGetLastError())
  289. return 0;
  290. if (WSAECONNRESET == WSAGetLastError())
  291. return 0;
  292. llinfos << "receivePacket() failed, Error: " << WSAGetLastError() << llendl;
  293. }
  294. return nRet;
  295. }
  296. // Returns TRUE on success.
  297. BOOL send_packet(int hSocket, const char *sendBuffer, int size, U32 recipient, int nPort)
  298. {
  299. //  Sends a packet to the address set in initNet
  300. //  
  301. int nRet = 0;
  302. U32 last_error = 0;
  303. stDstAddr.sin_addr.s_addr = recipient;
  304. stDstAddr.sin_port = htons(nPort);
  305. do
  306. {
  307. nRet = sendto(hSocket, sendBuffer, size, 0, (struct sockaddr*)&stDstAddr, sizeof(stDstAddr));
  308. if (nRet == SOCKET_ERROR ) 
  309. {
  310. last_error = WSAGetLastError();
  311. if (last_error != WSAEWOULDBLOCK)
  312. {
  313. // WSAECONNRESET - I think this is caused by an ICMP "connection refused"
  314. // message being sent back from a Linux box...  I'm not finding helpful
  315. // documentation or web pages on this.  The question is whether the packet
  316. // actually got sent or not.  Based on the structure of this code, I would
  317. // assume it is.  JNC 2002.01.18
  318. if (WSAECONNRESET == WSAGetLastError())
  319. {
  320. return TRUE;
  321. }
  322. llinfos << "sendto() failed to " << u32_to_ip_string(recipient) << ":" << nPort 
  323. << ", Error " << last_error << llendl;
  324. }
  325. }
  326. } while (  (nRet == SOCKET_ERROR)
  327.  &&(last_error == WSAEWOULDBLOCK));
  328. return (nRet != SOCKET_ERROR);
  329. }
  330. //////////////////////////////////////////////////////////////////////////////////////////
  331. // Linux Versions
  332. //////////////////////////////////////////////////////////////////////////////////////////
  333. #else
  334. //  Create socket, make non-blocking
  335. S32 start_net(S32& socket_out, int& nPort)
  336. {
  337. int hSocket, nRet;
  338. int snd_size = SEND_BUFFER_SIZE;
  339. int rec_size = RECEIVE_BUFFER_SIZE;
  340. socklen_t buff_size = 4;
  341.     
  342. //  Create socket
  343.     hSocket = socket(AF_INET, SOCK_DGRAM, 0);
  344.     if (hSocket < 0)
  345. {
  346. llwarns << "socket() failed" << llendl;
  347. return 1;
  348. }
  349. if (NET_USE_OS_ASSIGNED_PORT == nPort)
  350. {
  351. // Although bind is not required it will tell us which port we were
  352. // assigned to.
  353. stLclAddr.sin_family      = AF_INET;
  354. stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  355. stLclAddr.sin_port        = htons(0);
  356. llinfos << "attempting to connect on OS assigned port" << llendl;
  357. nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
  358. if (nRet < 0)
  359. {
  360. llwarns << "Failed to bind on an OS assigned port error: "
  361. << nRet << llendl;
  362. }
  363. else
  364. {
  365. sockaddr_in socket_info;
  366. socklen_t len = sizeof(sockaddr_in);
  367. int err = getsockname(hSocket, (sockaddr*)&socket_info, &len);
  368. llinfos << "Get socket returned: " << err << " length " << len << llendl;
  369. nPort = ntohs(socket_info.sin_port);
  370. llinfos << "Assigned port: " << nPort << llendl;
  371. }
  372. }
  373. else
  374. {
  375.     // Name the socket (assign the local port number to receive on)
  376. stLclAddr.sin_family      = AF_INET;
  377. stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  378. stLclAddr.sin_port        = htons(nPort);
  379. U32 attempt_port = nPort;
  380. llinfos << "attempting to connect on port " << attempt_port << llendl;
  381. nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
  382. if (nRet < 0)
  383. {
  384. // If we got an address in use error...
  385. if (errno == EADDRINUSE)
  386. {
  387. // Try all ports from PORT_DISCOVERY_RANGE_MIN to PORT_DISCOVERY_RANGE_MAX
  388. for(attempt_port = PORT_DISCOVERY_RANGE_MIN;
  389. attempt_port <= PORT_DISCOVERY_RANGE_MAX;
  390. attempt_port++)
  391. {
  392. stLclAddr.sin_port = htons(attempt_port);
  393. llinfos << "trying port " << attempt_port << llendl;
  394. nRet = bind(hSocket, (struct sockaddr*) &stLclAddr, sizeof(stLclAddr));
  395. if (!((nRet < 0) && (errno == EADDRINUSE)))
  396. {
  397. break;
  398. }
  399. }
  400. if (nRet < 0)
  401. {
  402. llwarns << "startNet() : Couldn't find available network port." << llendl;
  403. // Fail gracefully in release.
  404. return 3;
  405. }
  406. }
  407. // Some other socket error
  408. else
  409. {
  410. llwarns << llformat ("bind() port: %d failed, Err: %sn", nPort, strerror(errno)) << llendl;
  411. // Fail gracefully in release.
  412. return 4;
  413. }
  414. }
  415. llinfos << "connected on port " << attempt_port << llendl;
  416. nPort = attempt_port;
  417. }
  418. // Set socket to be non-blocking
  419.   fcntl(hSocket, F_SETFL, O_NONBLOCK);
  420. // set a large receive buffer
  421. nRet = setsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, buff_size);
  422. if (nRet)
  423. {
  424. llinfos << "Can't set receive size!" << llendl;
  425. }
  426. nRet = setsockopt(hSocket, SOL_SOCKET, SO_SNDBUF, (char *)&snd_size, buff_size);
  427. if (nRet)
  428. {
  429. llinfos << "Can't set send size!" << llendl;
  430. }
  431. getsockopt(hSocket, SOL_SOCKET, SO_RCVBUF, (char *)&rec_size, &buff_size);
  432. getsockopt(hSocket, SOL_SOCKET, SO_SNDBUF, (char *)&snd_size, &buff_size);
  433. llinfos << "startNet - receive buffer size : " << rec_size << llendl;
  434. llinfos << "startNet - send buffer size    : " << snd_size << llendl;
  435. #if LL_LINUX
  436. // Turn on recipient address tracking
  437. {
  438. int use_pktinfo = 1;
  439. if( setsockopt( hSocket, SOL_IP, IP_PKTINFO, &use_pktinfo, sizeof(use_pktinfo) ) == -1 )
  440. {
  441. llwarns << "No IP_PKTINFO available" << llendl;
  442. }
  443. else
  444. {
  445. llinfos << "IP_PKKTINFO enabled" << llendl;
  446. }
  447. }
  448. #endif
  449. //  Setup a destination address
  450. char achMCAddr[MAXADDRSTR] = "127.0.0.1"; /* Flawfinder: ignore */ 
  451. stDstAddr.sin_family =      AF_INET;
  452.         stDstAddr.sin_addr.s_addr = ip_string_to_u32(achMCAddr);
  453.         stDstAddr.sin_port =        htons(nPort);
  454. socket_out = hSocket;
  455. return 0;
  456. }
  457. void end_net(S32& socket_out)
  458. {
  459. if (socket_out >= 0)
  460. {
  461. close(socket_out);
  462. }
  463. }
  464. #if LL_LINUX
  465. static int recvfrom_destip( int socket, void *buf, int len, struct sockaddr *from, socklen_t *fromlen, U32 *dstip )
  466. {
  467. int size;
  468. struct iovec iov[1];
  469. char cmsg[CMSG_SPACE(sizeof(struct in_pktinfo))];
  470. struct cmsghdr *cmsgptr;
  471. struct msghdr msg = {0};
  472. iov[0].iov_base = buf;
  473. iov[0].iov_len = len;
  474. memset( &msg, 0, sizeof msg );
  475. msg.msg_name = from;
  476. msg.msg_namelen = *fromlen;
  477. msg.msg_iov = iov;
  478. msg.msg_iovlen = 1;
  479. msg.msg_control = &cmsg;
  480. msg.msg_controllen = sizeof(cmsg);
  481. size = recvmsg( socket, &msg, 0 );
  482. if( size == -1 )
  483. {
  484. return -1;
  485. }
  486. for( cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR( &msg, cmsgptr ) )
  487. {
  488. if( cmsgptr->cmsg_level == SOL_IP && cmsgptr->cmsg_type == IP_PKTINFO )
  489. {
  490. in_pktinfo *pktinfo = (in_pktinfo *)CMSG_DATA(cmsgptr);
  491. if( pktinfo )
  492. {
  493. // Two choices. routed and specified. ipi_addr is routed, ipi_spec_dst is
  494. // routed. We should stay with specified until we go to multiple
  495. // interfaces
  496. *dstip = pktinfo->ipi_spec_dst.s_addr;
  497. }
  498. }
  499. }
  500. return size;
  501. }
  502. #endif
  503. int receive_packet(int hSocket, char * receiveBuffer)
  504. {
  505. //  Receives data asynchronously from the socket set by initNet().
  506. //  Returns the number of bytes received into dataReceived, or zero
  507. //  if there is no data received.
  508. // or -1 if an error occured!
  509. int nRet;
  510. socklen_t addr_size = sizeof(struct sockaddr_in);
  511. gsnReceivingIFAddr = INVALID_HOST_IP_ADDRESS;
  512. #if LL_LINUX
  513. nRet = recvfrom_destip(hSocket, receiveBuffer, NET_BUFFER_SIZE, (struct sockaddr*)&stSrcAddr, &addr_size, &gsnReceivingIFAddr);
  514. #else
  515. int recv_flags = 0;
  516. nRet = recvfrom(hSocket, receiveBuffer, NET_BUFFER_SIZE, recv_flags, (struct sockaddr*)&stSrcAddr, &addr_size);
  517. #endif
  518. if (nRet == -1)
  519. {
  520. // To maintain consistency with the Windows implementation, return a zero for size on error.
  521. return 0;
  522. }
  523. // Uncomment for testing if/when implementing for Mac or Windows:
  524. // llinfos << "Received datagram to in addr " << u32_to_ip_string(get_receiving_interface_ip()) << llendl;
  525. return nRet;
  526. }
  527. BOOL send_packet(int hSocket, const char * sendBuffer, int size, U32 recipient, int nPort)
  528. {
  529. int ret;
  530. BOOL success;
  531. BOOL resend;
  532. S32 send_attempts = 0;
  533. stDstAddr.sin_addr.s_addr = recipient;
  534. stDstAddr.sin_port = htons(nPort);
  535. do
  536. {
  537. ret = sendto(hSocket, sendBuffer, size, 0, (struct sockaddr*)&stDstAddr, sizeof(stDstAddr));
  538. send_attempts++;
  539. if (ret >= 0)
  540. {
  541. // successful send
  542. success = TRUE;
  543. resend = FALSE;
  544. }
  545. else
  546. {
  547. // send failed, check to see if we should resend
  548. success = FALSE;
  549. if (errno == EAGAIN)
  550. {
  551. // say nothing, just repeat send
  552. llinfos << "sendto() reported buffer full, resending (attempt " << send_attempts << ")" << llendl;
  553. llinfos << inet_ntoa(stDstAddr.sin_addr) << ":" << nPort << llendl;
  554. resend = TRUE;
  555. }
  556. else if (errno == ECONNREFUSED)
  557. {
  558. // response to ICMP connection refused message on earlier send
  559. llinfos << "sendto() reported connection refused, resending (attempt " << send_attempts << ")" << llendl;
  560. llinfos << inet_ntoa(stDstAddr.sin_addr) << ":" << nPort << llendl;
  561. resend = TRUE;
  562. }
  563. else
  564. {
  565. // some other error
  566. llinfos << "sendto() failed: " << errno << ", " << strerror(errno) << llendl;
  567. llinfos << inet_ntoa(stDstAddr.sin_addr) << ":" << nPort << llendl;
  568. resend = FALSE;
  569. }
  570. }
  571. }
  572. while ( resend && send_attempts < 3);
  573. if (send_attempts >= 3)
  574. {
  575. llinfos << "sendPacket() bailed out of send!" << llendl;
  576. return FALSE;
  577. }
  578. return success;
  579. }
  580. #endif
  581. //EOF