00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "ns3/node.h"
00021 #include "ns3/inet-socket-address.h"
00022 #include "ns3/log.h"
00023 #include "ns3/ipv4.h"
00024 #include "ipv4-end-point.h"
00025 #include "nsc-tcp-l4-protocol.h"
00026 #include "nsc-tcp-socket-impl.h"
00027 #include "ns3/simulation-singleton.h"
00028 #include "tcp-typedefs.h"
00029 #include "ns3/simulator.h"
00030 #include "ns3/packet.h"
00031 #include "ns3/uinteger.h"
00032 #include "ns3/trace-source-accessor.h"
00033
00034 #include <algorithm>
00035
00036
00037 #include <arpa/inet.h>
00038 #include <netinet/in.h>
00039
00040 #include "sim_interface.h"
00041 #include "sim_errno.h"
00042
00043 NS_LOG_COMPONENT_DEFINE ("NscTcpSocketImpl");
00044
00045 using namespace std;
00046
00047 namespace ns3 {
00048
00049 NS_OBJECT_ENSURE_REGISTERED (NscTcpSocketImpl);
00050
00051 TypeId
00052 NscTcpSocketImpl::GetTypeId ()
00053 {
00054 static TypeId tid = TypeId("ns3::NscTcpSocketImpl")
00055 .SetParent<TcpSocket> ()
00056 .AddTraceSource ("CongestionWindow",
00057 "The TCP connection's congestion window",
00058 MakeTraceSourceAccessor (&NscTcpSocketImpl::m_cWnd))
00059 ;
00060 return tid;
00061 }
00062
00063 NscTcpSocketImpl::NscTcpSocketImpl ()
00064 : m_endPoint (0),
00065 m_node (0),
00066 m_tcp (0),
00067 m_localAddress (Ipv4Address::GetZero ()),
00068 m_localPort (0),
00069 m_peerAddress ("0.0.0.0", 0),
00070 m_errno (ERROR_NOTERROR),
00071 m_shutdownSend (false),
00072 m_shutdownRecv (false),
00073 m_connected (false),
00074 m_state (CLOSED),
00075 m_closeOnEmpty (false),
00076 m_txBufferSize (0),
00077 m_rtt (0),
00078 m_lastMeasuredRtt (Seconds(0.0))
00079 {
00080 NS_LOG_FUNCTION (this);
00081 }
00082
00083 NscTcpSocketImpl::NscTcpSocketImpl(const NscTcpSocketImpl& sock)
00084 : TcpSocket(sock),
00085 m_delAckMaxCount (sock.m_delAckMaxCount),
00086 m_delAckTimeout (sock.m_delAckTimeout),
00087 m_endPoint (0),
00088 m_node (sock.m_node),
00089 m_tcp (sock.m_tcp),
00090 m_remoteAddress (sock.m_remoteAddress),
00091 m_remotePort (sock.m_remotePort),
00092 m_localAddress (sock.m_localAddress),
00093 m_localPort (sock.m_localPort),
00094 m_peerAddress (sock.m_peerAddress),
00095 m_errno (sock.m_errno),
00096 m_shutdownSend (sock.m_shutdownSend),
00097 m_shutdownRecv (sock.m_shutdownRecv),
00098 m_connected (sock.m_connected),
00099 m_state (sock.m_state),
00100 m_closeOnEmpty (sock.m_closeOnEmpty),
00101 m_segmentSize (sock.m_segmentSize),
00102 m_rxWindowSize (sock.m_rxWindowSize),
00103 m_advertisedWindowSize (sock.m_advertisedWindowSize),
00104 m_cWnd (sock.m_cWnd),
00105 m_ssThresh (sock.m_ssThresh),
00106 m_initialCWnd (sock.m_initialCWnd),
00107 m_rtt (0),
00108 m_lastMeasuredRtt (Seconds(0.0)),
00109 m_cnTimeout (sock.m_cnTimeout),
00110 m_cnCount (sock.m_cnCount),
00111 m_rxAvailable (0),
00112 m_nscTcpSocket (0),
00113 m_sndBufSize (sock.m_sndBufSize)
00114 {
00115 NS_LOG_FUNCTION_NOARGS ();
00116 NS_LOG_LOGIC("Invoked the copy constructor");
00117
00118 if(!sock.m_txBuffer.empty () )
00119 {
00120 m_txBuffer = sock.m_txBuffer;
00121 }
00122
00123 if (sock.m_rtt)
00124 {
00125 m_rtt = sock.m_rtt->Copy();
00126 }
00127
00128
00129 }
00130
00131 NscTcpSocketImpl::~NscTcpSocketImpl ()
00132 {
00133 NS_LOG_FUNCTION(this);
00134 m_node = 0;
00135 if (m_endPoint != 0)
00136 {
00137 NS_ASSERT (m_tcp != 0);
00138
00139
00140
00141
00142
00143
00144
00145
00146 NS_ASSERT (m_endPoint != 0);
00147 m_tcp->DeAllocate (m_endPoint);
00148 NS_ASSERT (m_endPoint == 0);
00149 }
00150 m_tcp = 0;
00151 }
00152
00153 void
00154 NscTcpSocketImpl::SetNode (Ptr<Node> node)
00155 {
00156 m_node = node;
00157
00158 m_cWnd = m_initialCWnd * m_segmentSize;
00159 m_rxWindowSize = m_advertisedWindowSize;
00160 }
00161
00162 void
00163 NscTcpSocketImpl::SetTcp (Ptr<NscTcpL4Protocol> tcp)
00164 {
00165 m_nscTcpSocket = tcp->m_nscStack->new_tcp_socket();
00166 m_tcp = tcp;
00167 }
00168 void
00169 NscTcpSocketImpl::SetRtt (Ptr<RttEstimator> rtt)
00170 {
00171 m_rtt = rtt;
00172 }
00173
00174
00175 enum Socket::SocketErrno
00176 NscTcpSocketImpl::GetErrno (void) const
00177 {
00178 NS_LOG_FUNCTION_NOARGS ();
00179 return m_errno;
00180 }
00181
00182 Ptr<Node>
00183 NscTcpSocketImpl::GetNode (void) const
00184 {
00185 NS_LOG_FUNCTION_NOARGS ();
00186 return m_node;
00187 }
00188
00189 void
00190 NscTcpSocketImpl::Destroy (void)
00191 {
00192 NS_LOG_FUNCTION_NOARGS ();
00193 m_node = 0;
00194 m_endPoint = 0;
00195 m_tcp = 0;
00196 }
00197 int
00198 NscTcpSocketImpl::FinishBind (void)
00199 {
00200 NS_LOG_FUNCTION_NOARGS ();
00201 if (m_endPoint == 0)
00202 {
00203 return -1;
00204 }
00205 m_endPoint->SetRxCallback (MakeCallback (&NscTcpSocketImpl::ForwardUp, Ptr<NscTcpSocketImpl>(this)));
00206 m_endPoint->SetDestroyCallback (MakeCallback (&NscTcpSocketImpl::Destroy, Ptr<NscTcpSocketImpl>(this)));
00207 m_localAddress = m_endPoint->GetLocalAddress ();
00208 m_localPort = m_endPoint->GetLocalPort ();
00209 return 0;
00210 }
00211
00212 int
00213 NscTcpSocketImpl::Bind (void)
00214 {
00215 NS_LOG_FUNCTION_NOARGS ();
00216 m_endPoint = m_tcp->Allocate ();
00217 return FinishBind ();
00218 }
00219 int
00220 NscTcpSocketImpl::Bind (const Address &address)
00221 {
00222 NS_LOG_FUNCTION (this<<address);
00223 if (!InetSocketAddress::IsMatchingType (address))
00224 {
00225 return ERROR_INVAL;
00226 }
00227 InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
00228 Ipv4Address ipv4 = transport.GetIpv4 ();
00229 uint16_t port = transport.GetPort ();
00230 if (ipv4 == Ipv4Address::GetAny () && port == 0)
00231 {
00232 m_endPoint = m_tcp->Allocate ();
00233 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00234 }
00235 else if (ipv4 == Ipv4Address::GetAny () && port != 0)
00236 {
00237 m_endPoint = m_tcp->Allocate (port);
00238 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00239 }
00240 else if (ipv4 != Ipv4Address::GetAny () && port == 0)
00241 {
00242 m_endPoint = m_tcp->Allocate (ipv4);
00243 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00244 }
00245 else if (ipv4 != Ipv4Address::GetAny () && port != 0)
00246 {
00247 m_endPoint = m_tcp->Allocate (ipv4, port);
00248 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00249 }
00250
00251 m_localPort = port;
00252 return FinishBind ();
00253 }
00254
00255 int
00256 NscTcpSocketImpl::ShutdownSend (void)
00257 {
00258 NS_LOG_FUNCTION_NOARGS ();
00259 m_shutdownSend = true;
00260 return 0;
00261 }
00262 int
00263 NscTcpSocketImpl::ShutdownRecv (void)
00264 {
00265 NS_LOG_FUNCTION_NOARGS ();
00266 m_shutdownRecv = false;
00267 return 0;
00268 }
00269
00270 int
00271 NscTcpSocketImpl::Close (void)
00272 {
00273 NS_LOG_FUNCTION (this << m_state);
00274
00275 if (m_state == CLOSED)
00276 {
00277 return -1;
00278 }
00279 if (!m_txBuffer.empty ())
00280 {
00281 m_closeOnEmpty = true;
00282 NS_LOG_LOGIC("Socket " << this <<
00283 " deferring close, state " << m_state);
00284 return 0;
00285 }
00286
00287 m_nscTcpSocket->disconnect();
00288 m_state = CLOSED;
00289 ShutdownSend ();
00290 return 0;
00291 }
00292
00293 int
00294 NscTcpSocketImpl::Connect (const Address & address)
00295 {
00296 NS_LOG_FUNCTION (this << address);
00297 if (m_endPoint == 0)
00298 {
00299 if (Bind () == -1)
00300 {
00301 NS_ASSERT (m_endPoint == 0);
00302 return -1;
00303 }
00304 NS_ASSERT (m_endPoint != 0);
00305 }
00306 InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
00307 m_remoteAddress = transport.GetIpv4 ();
00308 m_remotePort = transport.GetPort ();
00309
00310 std::ostringstream ss;
00311 m_remoteAddress.Print(ss);
00312 std::string ipstring = ss.str ();
00313
00314 m_nscTcpSocket->connect(ipstring.c_str (), m_remotePort);
00315 m_state = SYN_SENT;
00316 return 0;
00317 }
00318
00319 int
00320 NscTcpSocketImpl::Send (const Ptr<Packet> p, uint32_t flags)
00321 {
00322 NS_LOG_FUNCTION (this << p);
00323
00324 NS_ASSERT (p->GetSize () > 0);
00325 if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)
00326 {
00327 if (p->GetSize () > GetTxAvailable ())
00328 {
00329 m_errno = ERROR_MSGSIZE;
00330 return -1;
00331 }
00332
00333 uint32_t sent = p->GetSize ();
00334 if (m_state == ESTABLISHED)
00335 {
00336 m_txBuffer.push(p);
00337 m_txBufferSize += sent;
00338 SendPendingData();
00339 }
00340 else
00341 {
00342 m_txBuffer.push(p);
00343 m_txBufferSize += sent;
00344 }
00345 return sent;
00346 }
00347 else
00348 {
00349 m_errno = ERROR_NOTCONN;
00350 return -1;
00351 }
00352 }
00353
00354 int
00355 NscTcpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
00356 {
00357 NS_LOG_FUNCTION (this << address << p);
00358 if (!m_connected)
00359 {
00360 m_errno = ERROR_NOTCONN;
00361 return -1;
00362 }
00363 else
00364 {
00365 return Send (p, flags);
00366 }
00367 }
00368
00369 uint32_t
00370 NscTcpSocketImpl::GetTxAvailable (void) const
00371 {
00372 NS_LOG_FUNCTION_NOARGS ();
00373 if (m_txBufferSize != 0)
00374 {
00375 NS_ASSERT (m_txBufferSize <= m_sndBufSize);
00376 return m_sndBufSize - m_txBufferSize;
00377 }
00378 else
00379 {
00380 return m_sndBufSize;
00381 }
00382 }
00383
00384 int
00385 NscTcpSocketImpl::Listen (void)
00386 {
00387 NS_LOG_FUNCTION (this);
00388 m_nscTcpSocket->listen(m_localPort);
00389 m_state = LISTEN;
00390 return 0;
00391 }
00392
00393
00394 void
00395 NscTcpSocketImpl::NSCWakeup ()
00396 {
00397 switch (m_state) {
00398 case SYN_SENT:
00399 if (!m_nscTcpSocket->is_connected())
00400 break;
00401 m_state = ESTABLISHED;
00402 Simulator::ScheduleNow(&NscTcpSocketImpl::ConnectionSucceeded, this);
00403
00404 case ESTABLISHED:
00405 if (!m_txBuffer.empty ())
00406 Simulator::ScheduleNow(&NscTcpSocketImpl::SendPendingData, this);
00407 Simulator::ScheduleNow(&NscTcpSocketImpl::ReadPendingData, this);
00408 break;
00409 case LISTEN:
00410 Simulator::ScheduleNow(&NscTcpSocketImpl::Accept, this);
00411 break;
00412 case CLOSED: break;
00413 default:
00414 NS_LOG_DEBUG (this << " invalid state: " << m_state);
00415 }
00416 }
00417
00418 Ptr<Packet>
00419 NscTcpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
00420 {
00421 NS_LOG_FUNCTION_NOARGS ();
00422 if (m_deliveryQueue.empty() )
00423 {
00424 m_errno = ERROR_AGAIN;
00425 return 0;
00426 }
00427 Ptr<Packet> p = m_deliveryQueue.front ();
00428 if (p->GetSize () <= maxSize)
00429 {
00430 m_deliveryQueue.pop ();
00431 m_rxAvailable -= p->GetSize ();
00432 }
00433 else
00434 {
00435 m_errno = ERROR_AGAIN;
00436 p = 0;
00437 }
00438 return p;
00439 }
00440
00441 Ptr<Packet>
00442 NscTcpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
00443 Address &fromAddress)
00444 {
00445 NS_LOG_FUNCTION (this << maxSize << flags);
00446 Ptr<Packet> packet = Recv (maxSize, flags);
00447 if (packet != 0)
00448 {
00449 SocketAddressTag tag;
00450 bool found;
00451 found = packet->FindFirstMatchingTag (tag);
00452 NS_ASSERT (found);
00453 fromAddress = tag.GetAddress ();
00454 }
00455 return packet;
00456 }
00457
00458 int
00459 NscTcpSocketImpl::GetSockName (Address &address) const
00460 {
00461 NS_LOG_FUNCTION_NOARGS ();
00462 address = InetSocketAddress(m_localAddress, m_localPort);
00463 return 0;
00464 }
00465
00466 uint32_t
00467 NscTcpSocketImpl::GetRxAvailable (void) const
00468 {
00469 NS_LOG_FUNCTION_NOARGS ();
00470
00471
00472 return m_rxAvailable;
00473 }
00474
00475 void
00476 NscTcpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)
00477 {
00478 NSCWakeup();
00479 }
00480
00481 void NscTcpSocketImpl::CompleteFork(void)
00482 {
00483
00484
00485
00486
00487
00488 struct sockaddr_in sin;
00489 size_t sin_len = sizeof(sin);
00490
00491 if (0 == m_nscTcpSocket->getpeername((struct sockaddr*) &sin, &sin_len)) {
00492 m_remotePort = ntohs(sin.sin_port);
00493 m_remoteAddress = m_remoteAddress.Deserialize((const uint8_t*) &sin.sin_addr);
00494 m_peerAddress = InetSocketAddress(m_remoteAddress, m_remotePort);
00495 }
00496
00497 m_endPoint = m_tcp->Allocate ();
00498
00499
00500 NS_ASSERT(m_state == LISTEN);
00501 m_state = ESTABLISHED;
00502
00503 sin_len = sizeof(sin);
00504
00505 if (0 == m_nscTcpSocket->getsockname((struct sockaddr *) &sin, &sin_len))
00506 m_localAddress = m_localAddress.Deserialize((const uint8_t*) &sin.sin_addr);
00507
00508 NS_LOG_LOGIC ("NscTcpSocketImpl " << this << " accepted connection from "
00509 << m_remoteAddress << ":" << m_remotePort
00510 << " to " << m_localAddress << ":" << m_localPort);
00511
00512 m_endPoint->SetRxCallback (MakeCallback (&NscTcpSocketImpl::ForwardUp, Ptr<NscTcpSocketImpl>(this)));
00513 m_endPoint->SetDestroyCallback (MakeCallback (&NscTcpSocketImpl::Destroy, Ptr<NscTcpSocketImpl>(this)));
00514
00515 NotifyNewConnectionCreated (this, m_peerAddress);
00516 }
00517
00518 void NscTcpSocketImpl::ConnectionSucceeded()
00519 {
00520
00521
00522 struct sockaddr_in sin;
00523 size_t sin_len = sizeof(sin);
00524 if (0 == m_nscTcpSocket->getsockname((struct sockaddr *) &sin, &sin_len)) {
00525 m_localAddress = m_localAddress.Deserialize((const uint8_t*)&sin.sin_addr);
00526 m_localPort = ntohs(sin.sin_port);
00527 }
00528
00529 NS_LOG_LOGIC ("NscTcpSocketImpl " << this << " connected to "
00530 << m_remoteAddress << ":" << m_remotePort
00531 << " from " << m_localAddress << ":" << m_localPort);
00532 NotifyConnectionSucceeded();
00533 }
00534
00535
00536 bool NscTcpSocketImpl::Accept (void)
00537 {
00538 if (m_state == CLOSED)
00539 {
00540 return false;
00541 }
00542 NS_ASSERT (m_state == LISTEN);
00543
00544 if (!m_nscTcpSocket->is_listening())
00545 {
00546 return false;
00547 }
00548 INetStreamSocket *newsock;
00549 int res = m_nscTcpSocket->accept(&newsock);
00550 if (res != 0)
00551 {
00552 return false;
00553 }
00554
00555
00556
00557
00558
00559
00560
00561 Ptr<NscTcpSocketImpl> newSock = Copy ();
00562 newSock->m_nscTcpSocket = newsock;
00563 NS_LOG_LOGIC ("Cloned a NscTcpSocketImpl " << newSock);
00564
00565 Simulator::ScheduleNow (&NscTcpSocketImpl::CompleteFork, newSock);
00566 return true;
00567 }
00568
00569 bool NscTcpSocketImpl::ReadPendingData (void)
00570 {
00571 if (m_state != ESTABLISHED)
00572 {
00573 return false;
00574 }
00575 int len, err;
00576 uint8_t buffer[8192];
00577 len = sizeof(buffer);
00578 m_errno = ERROR_NOTERROR;
00579 err = m_nscTcpSocket->read_data(buffer, &len);
00580 if (err == 0 && len == 0)
00581 {
00582 NS_LOG_LOGIC ("ReadPendingData got EOF from socket");
00583 m_state = CLOSED;
00584 return false;
00585 }
00586 m_errno = GetNativeNs3Errno(err);
00587 switch (m_errno)
00588 {
00589 case ERROR_NOTERROR: break;
00590 case ERROR_AGAIN: return false;
00591 default:
00592 NS_LOG_WARN ("Error (" << err << ") " <<
00593 "during read_data, ns-3 errno set to" << m_errno);
00594 m_state = CLOSED;
00595 return false;
00596 }
00597
00598 Ptr<Packet> p = Create<Packet> (buffer, len);
00599
00600 SocketAddressTag tag;
00601
00602 tag.SetAddress (m_peerAddress);
00603 p->AddTag (tag);
00604 m_deliveryQueue.push (p);
00605 m_rxAvailable += p->GetSize ();
00606
00607 NotifyDataRecv ();
00608 return true;
00609 }
00610
00611 bool NscTcpSocketImpl::SendPendingData (void)
00612 {
00613 NS_LOG_FUNCTION (this);
00614 NS_LOG_LOGIC ("ENTERING SendPendingData");
00615
00616 if (m_txBuffer.empty ())
00617 {
00618 return false;
00619 }
00620
00621 int ret;
00622 size_t size, written = 0;
00623
00624 do {
00625 NS_ASSERT (!m_txBuffer.empty ());
00626 Ptr<Packet> &p = m_txBuffer.front ();
00627 size = p->GetSize ();
00628 NS_ASSERT (size > 0);
00629
00630 m_errno = ERROR_NOTERROR;
00631 ret = m_nscTcpSocket->send_data((const char *)p->PeekData (), size);
00632 if (ret <= 0)
00633 {
00634 break;
00635 }
00636 written += ret;
00637
00638 NS_ASSERT (m_txBufferSize >= (size_t)ret);
00639 m_txBufferSize -= ret;
00640
00641 if ((size_t)ret < size)
00642 {
00643 p->RemoveAtStart(ret);
00644 break;
00645 }
00646
00647 m_txBuffer.pop ();
00648
00649 if (m_txBuffer.empty ())
00650 {
00651 if (m_closeOnEmpty)
00652 {
00653 m_nscTcpSocket->disconnect();
00654 m_state = CLOSED;
00655 }
00656 break;
00657 }
00658 } while ((size_t) ret == size);
00659
00660 if (written > 0)
00661 {
00662 Simulator::ScheduleNow(&NscTcpSocketImpl::NotifyDataSent, this, ret);
00663 return true;
00664 }
00665 return false;
00666 }
00667
00668 Ptr<NscTcpSocketImpl> NscTcpSocketImpl::Copy ()
00669 {
00670 return CopyObject<NscTcpSocketImpl> (this);
00671 }
00672
00673 void
00674 NscTcpSocketImpl::SetSndBufSize (uint32_t size)
00675 {
00676 m_sndBufSize = size;
00677 }
00678
00679 uint32_t
00680 NscTcpSocketImpl::GetSndBufSize (void) const
00681 {
00682 return m_sndBufSize;
00683 }
00684
00685 void
00686 NscTcpSocketImpl::SetRcvBufSize (uint32_t size)
00687 {
00688 m_rcvBufSize = size;
00689 }
00690
00691 uint32_t
00692 NscTcpSocketImpl::GetRcvBufSize (void) const
00693 {
00694 return m_rcvBufSize;
00695 }
00696
00697 void
00698 NscTcpSocketImpl::SetSegSize (uint32_t size)
00699 {
00700 m_segmentSize = size;
00701 }
00702
00703 uint32_t
00704 NscTcpSocketImpl::GetSegSize (void) const
00705 {
00706 return m_segmentSize;
00707 }
00708
00709 void
00710 NscTcpSocketImpl::SetAdvWin (uint32_t window)
00711 {
00712 m_advertisedWindowSize = window;
00713 }
00714
00715 uint32_t
00716 NscTcpSocketImpl::GetAdvWin (void) const
00717 {
00718 return m_advertisedWindowSize;
00719 }
00720
00721 void
00722 NscTcpSocketImpl::SetSSThresh (uint32_t threshold)
00723 {
00724 m_ssThresh = threshold;
00725 }
00726
00727 uint32_t
00728 NscTcpSocketImpl::GetSSThresh (void) const
00729 {
00730 return m_ssThresh;
00731 }
00732
00733 void
00734 NscTcpSocketImpl::SetInitialCwnd (uint32_t cwnd)
00735 {
00736 m_initialCWnd = cwnd;
00737 }
00738
00739 uint32_t
00740 NscTcpSocketImpl::GetInitialCwnd (void) const
00741 {
00742 return m_initialCWnd;
00743 }
00744
00745 void
00746 NscTcpSocketImpl::SetConnTimeout (Time timeout)
00747 {
00748 m_cnTimeout = timeout;
00749 }
00750
00751 Time
00752 NscTcpSocketImpl::GetConnTimeout (void) const
00753 {
00754 return m_cnTimeout;
00755 }
00756
00757 void
00758 NscTcpSocketImpl::SetConnCount (uint32_t count)
00759 {
00760 m_cnCount = count;
00761 }
00762
00763 uint32_t
00764 NscTcpSocketImpl::GetConnCount (void) const
00765 {
00766 return m_cnCount;
00767 }
00768
00769 void
00770 NscTcpSocketImpl::SetDelAckTimeout (Time timeout)
00771 {
00772 m_delAckTimeout = timeout;
00773 }
00774
00775 Time
00776 NscTcpSocketImpl::GetDelAckTimeout (void) const
00777 {
00778 return m_delAckTimeout;
00779 }
00780
00781 void
00782 NscTcpSocketImpl::SetDelAckMaxCount (uint32_t count)
00783 {
00784 m_delAckMaxCount = count;
00785 }
00786
00787 uint32_t
00788 NscTcpSocketImpl::GetDelAckMaxCount (void) const
00789 {
00790 return m_delAckMaxCount;
00791 }
00792
00793 enum Socket::SocketErrno
00794 NscTcpSocketImpl::GetNativeNs3Errno(int error) const
00795 {
00796 enum nsc_errno err;
00797
00798 if (error >= 0)
00799 {
00800 return ERROR_NOTERROR;
00801 }
00802 err = (enum nsc_errno) error;
00803 switch (err)
00804 {
00805 case NSC_EADDRINUSE:
00806 case NSC_EADDRNOTAVAIL: return ERROR_AFNOSUPPORT;
00807 case NSC_EINPROGRESS:
00808 case NSC_EAGAIN: return ERROR_AGAIN;
00809 case NSC_EISCONN:
00810 case NSC_EALREADY: return ERROR_ISCONN;
00811 case NSC_ECONNREFUSED: return ERROR_NOROUTETOHOST;
00812 case NSC_ECONNRESET:
00813 case NSC_EHOSTDOWN:
00814 case NSC_ENETUNREACH:
00815 case NSC_EHOSTUNREACH: return ERROR_NOROUTETOHOST;
00816 case NSC_EMSGSIZE: return ERROR_MSGSIZE;
00817 case NSC_ENOTCONN: return ERROR_NOTCONN;
00818 case NSC_ESHUTDOWN: return ERROR_SHUTDOWN;
00819 case NSC_ETIMEDOUT: return ERROR_NOTCONN;
00820 case NSC_ENOTDIR:
00821
00822 case NSC_EUNKNOWN: return ERROR_INVAL;
00823 }
00824 NS_ASSERT_MSG(0, "Unknown NSC error");
00825 return ERROR_INVAL;
00826 }
00827
00828 }