00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "ns3/node.h"
00023 #include "ns3/inet-socket-address.h"
00024 #include "ns3/log.h"
00025 #include "ns3/ipv4.h"
00026 #include "tcp-socket-impl.h"
00027 #include "tcp-l4-protocol.h"
00028 #include "ipv4-end-point.h"
00029 #include "ns3/simulation-singleton.h"
00030 #include "tcp-typedefs.h"
00031 #include "ns3/simulator.h"
00032 #include "ns3/packet.h"
00033 #include "ns3/uinteger.h"
00034 #include "ns3/trace-source-accessor.h"
00035
00036 #include <algorithm>
00037
00038 NS_LOG_COMPONENT_DEFINE ("TcpSocketImpl");
00039
00040 using namespace std;
00041
00042 namespace ns3 {
00043
00044 NS_OBJECT_ENSURE_REGISTERED (TcpSocketImpl);
00045
00046 TypeId
00047 TcpSocketImpl::GetTypeId ()
00048 {
00049 static TypeId tid = TypeId("ns3::TcpSocketImpl")
00050 .SetParent<TcpSocket> ()
00051 .AddTraceSource ("CongestionWindow",
00052 "The TCP connection's congestion window",
00053 MakeTraceSourceAccessor (&TcpSocketImpl::m_cWnd))
00054 ;
00055 return tid;
00056 }
00057
00058 TcpSocketImpl::TcpSocketImpl ()
00059 : m_skipRetxResched (false),
00060 m_dupAckCount (0),
00061 m_delAckCount (0),
00062 m_endPoint (0),
00063 m_node (0),
00064 m_tcp (0),
00065 m_localAddress (Ipv4Address::GetZero ()),
00066 m_localPort (0),
00067 m_errno (ERROR_NOTERROR),
00068 m_shutdownSend (false),
00069 m_shutdownRecv (false),
00070 m_connected (false),
00071 m_state (CLOSED),
00072 m_closeNotified (false),
00073 m_closeRequestNotified (false),
00074 m_closeOnEmpty (false),
00075 m_pendingClose (false),
00076 m_nextTxSequence (0),
00077 m_highTxMark (0),
00078 m_highestRxAck (0),
00079 m_lastRxAck (0),
00080 m_nextRxSequence (0),
00081 m_rxAvailable (0),
00082 m_rxBufSize (0),
00083 m_pendingData (0),
00084 m_rxWindowSize (0),
00085 m_persistTime (Seconds(6)),
00086 m_rtt (0),
00087 m_lastMeasuredRtt (Seconds(0.0))
00088 {
00089 NS_LOG_FUNCTION (this);
00090 }
00091
00092 TcpSocketImpl::TcpSocketImpl(const TcpSocketImpl& sock)
00093 : TcpSocket(sock),
00094 m_skipRetxResched (sock.m_skipRetxResched),
00095 m_dupAckCount (sock.m_dupAckCount),
00096 m_delAckCount (0),
00097 m_delAckMaxCount (sock.m_delAckMaxCount),
00098 m_delAckTimeout (sock.m_delAckTimeout),
00099 m_endPoint (0),
00100 m_node (sock.m_node),
00101 m_tcp (sock.m_tcp),
00102 m_remoteAddress (sock.m_remoteAddress),
00103 m_remotePort (sock.m_remotePort),
00104 m_localAddress (sock.m_localAddress),
00105 m_localPort (sock.m_localPort),
00106 m_errno (sock.m_errno),
00107 m_shutdownSend (sock.m_shutdownSend),
00108 m_shutdownRecv (sock.m_shutdownRecv),
00109 m_connected (sock.m_connected),
00110 m_state (sock.m_state),
00111 m_closeNotified (sock.m_closeNotified),
00112 m_closeRequestNotified (sock.m_closeRequestNotified),
00113 m_closeOnEmpty (sock.m_closeOnEmpty),
00114 m_pendingClose (sock.m_pendingClose),
00115 m_nextTxSequence (sock.m_nextTxSequence),
00116 m_highTxMark (sock.m_highTxMark),
00117 m_highestRxAck (sock.m_highestRxAck),
00118 m_lastRxAck (sock.m_lastRxAck),
00119 m_nextRxSequence (sock.m_nextRxSequence),
00120 m_rxAvailable (0),
00121 m_rxBufSize (0),
00122 m_pendingData (0),
00123 m_segmentSize (sock.m_segmentSize),
00124 m_rxWindowSize (sock.m_rxWindowSize),
00125 m_cWnd (sock.m_cWnd),
00126 m_ssThresh (sock.m_ssThresh),
00127 m_initialCWnd (sock.m_initialCWnd),
00128 m_persistTime (sock.m_persistTime),
00129 m_rtt (0),
00130 m_lastMeasuredRtt (Seconds(0.0)),
00131 m_cnTimeout (sock.m_cnTimeout),
00132 m_cnCount (sock.m_cnCount),
00133 m_sndBufSize (sock.m_sndBufSize),
00134 m_rxBufMaxSize(sock.m_rxBufMaxSize)
00135 {
00136 NS_LOG_FUNCTION_NOARGS ();
00137 NS_LOG_LOGIC("Invoked the copy constructor");
00138
00139 if(sock.m_pendingData)
00140 {
00141 m_pendingData = sock.m_pendingData->Copy();
00142 }
00143
00144 if (sock.m_rtt)
00145 {
00146 m_rtt = sock.m_rtt->Copy();
00147 }
00148
00149
00150 Callback<void, Ptr< Socket > > vPS =
00151 MakeNullCallback<void, Ptr<Socket> > ();
00152 Callback<void, Ptr<Socket>, const Address &> vPSA =
00153 MakeNullCallback<void, Ptr<Socket>, const Address &> ();
00154 Callback<void, Ptr<Socket>, uint32_t> vPSUI =
00155 MakeNullCallback<void, Ptr<Socket>, uint32_t> ();
00156
00157 SetConnectCallback (vPS, vPS);
00158 SetDataSentCallback (vPSUI);
00159 SetSendCallback (vPSUI);
00160 SetRecvCallback (vPS);
00161
00162
00163 }
00164
00165 TcpSocketImpl::~TcpSocketImpl ()
00166 {
00167 NS_LOG_FUNCTION(this);
00168 m_node = 0;
00169 if (m_endPoint != 0)
00170 {
00171 NS_ASSERT (m_tcp != 0);
00172
00173
00174
00175
00176
00177
00178
00179
00180 NS_ASSERT (m_endPoint != 0);
00181 m_tcp->DeAllocate (m_endPoint);
00182 NS_ASSERT (m_endPoint == 0);
00183 }
00184 m_tcp = 0;
00185 delete m_pendingData;
00186 m_pendingData = 0;
00187 }
00188
00189 void
00190 TcpSocketImpl::SetNode (Ptr<Node> node)
00191 {
00192 m_node = node;
00193
00194 m_cWnd = m_initialCWnd * m_segmentSize;
00195 }
00196
00197 void
00198 TcpSocketImpl::SetTcp (Ptr<TcpL4Protocol> tcp)
00199 {
00200 m_tcp = tcp;
00201 }
00202 void
00203 TcpSocketImpl::SetRtt (Ptr<RttEstimator> rtt)
00204 {
00205 m_rtt = rtt;
00206 }
00207
00208
00209 enum Socket::SocketErrno
00210 TcpSocketImpl::GetErrno (void) const
00211 {
00212 NS_LOG_FUNCTION_NOARGS ();
00213 return m_errno;
00214 }
00215
00216 Ptr<Node>
00217 TcpSocketImpl::GetNode (void) const
00218 {
00219 NS_LOG_FUNCTION_NOARGS ();
00220 return m_node;
00221 }
00222
00223 void
00224 TcpSocketImpl::Destroy (void)
00225 {
00226 NS_LOG_FUNCTION_NOARGS ();
00227 m_node = 0;
00228 m_endPoint = 0;
00229 m_tcp = 0;
00230 NS_LOG_LOGIC (this<<" Cancelled ReTxTimeout event which was set to expire at "
00231 << (Simulator::Now () +
00232 Simulator::GetDelayLeft (m_retxEvent)).GetSeconds());
00233 m_retxEvent.Cancel ();
00234 }
00235 int
00236 TcpSocketImpl::FinishBind (void)
00237 {
00238 NS_LOG_FUNCTION_NOARGS ();
00239 if (m_endPoint == 0)
00240 {
00241 return -1;
00242 }
00243 m_endPoint->SetRxCallback (MakeCallback (&TcpSocketImpl::ForwardUp, Ptr<TcpSocketImpl>(this)));
00244 m_endPoint->SetDestroyCallback (MakeCallback (&TcpSocketImpl::Destroy, Ptr<TcpSocketImpl>(this)));
00245 m_localAddress = m_endPoint->GetLocalAddress ();
00246 m_localPort = m_endPoint->GetLocalPort ();
00247 return 0;
00248 }
00249
00250 int
00251 TcpSocketImpl::Bind (void)
00252 {
00253 NS_LOG_FUNCTION_NOARGS ();
00254 m_endPoint = m_tcp->Allocate ();
00255 return FinishBind ();
00256 }
00257 int
00258 TcpSocketImpl::Bind (const Address &address)
00259 {
00260 NS_LOG_FUNCTION (this<<address);
00261 if (!InetSocketAddress::IsMatchingType (address))
00262 {
00263 m_errno = ERROR_INVAL;
00264 return -1;
00265 }
00266 InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
00267 Ipv4Address ipv4 = transport.GetIpv4 ();
00268 uint16_t port = transport.GetPort ();
00269 if (ipv4 == Ipv4Address::GetAny () && port == 0)
00270 {
00271 m_endPoint = m_tcp->Allocate ();
00272 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00273 }
00274 else if (ipv4 == Ipv4Address::GetAny () && port != 0)
00275 {
00276 m_endPoint = m_tcp->Allocate (port);
00277 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00278 }
00279 else if (ipv4 != Ipv4Address::GetAny () && port == 0)
00280 {
00281 m_endPoint = m_tcp->Allocate (ipv4);
00282 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00283 }
00284 else if (ipv4 != Ipv4Address::GetAny () && port != 0)
00285 {
00286 m_endPoint = m_tcp->Allocate (ipv4, port);
00287 NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
00288 }
00289
00290 return FinishBind ();
00291 }
00292
00293 int
00294 TcpSocketImpl::ShutdownSend (void)
00295 {
00296 NS_LOG_FUNCTION_NOARGS ();
00297 m_shutdownSend = true;
00298 return 0;
00299 }
00300 int
00301 TcpSocketImpl::ShutdownRecv (void)
00302 {
00303 NS_LOG_FUNCTION_NOARGS ();
00304 m_shutdownRecv = false;
00305 return 0;
00306 }
00307
00308 int
00309 TcpSocketImpl::Close (void)
00310 {
00311 NS_LOG_FUNCTION_NOARGS ();
00312 if (m_pendingData && m_pendingData->Size() != 0)
00313 {
00314 m_closeOnEmpty = true;
00315 NS_LOG_LOGIC("Socket " << this <<
00316 " deferring close, state " << m_state);
00317 return 0;
00318 }
00319
00320 Actions_t action = ProcessEvent (APP_CLOSE);
00321 ProcessAction (action);
00322 ShutdownSend ();
00323 return 0;
00324 }
00325
00326 int
00327 TcpSocketImpl::Connect (const Address & address)
00328 {
00329 NS_LOG_FUNCTION (this << address);
00330 if (m_endPoint == 0)
00331 {
00332 if (Bind () == -1)
00333 {
00334 NS_ASSERT (m_endPoint == 0);
00335 return -1;
00336 }
00337 NS_ASSERT (m_endPoint != 0);
00338 }
00339 InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
00340 m_remoteAddress = transport.GetIpv4 ();
00341 m_remotePort = transport.GetPort ();
00342
00343 uint32_t localIfIndex;
00344 Ptr<Ipv4> ipv4 = m_node->GetObject<Ipv4> ();
00345
00346 if (ipv4->GetIfIndexForDestination (m_remoteAddress, localIfIndex))
00347 {
00348 m_endPoint->SetLocalAddress (ipv4->GetAddress (localIfIndex));
00349 }
00350 else
00351 {
00352 m_errno = ERROR_NOROUTETOHOST;
00353 return -1;
00354 }
00355
00356 Actions_t action = ProcessEvent (APP_CONNECT);
00357 bool success = ProcessAction (action);
00358 if (success)
00359 {
00360 return 0;
00361 }
00362 return -1;
00363 }
00364
00365
00366 int
00367 TcpSocketImpl::Send (Ptr<Packet> p, uint32_t flags)
00368 {
00369 NS_LOG_FUNCTION (this << p);
00370 if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)
00371 {
00372 if (p->GetSize() > GetTxAvailable ())
00373 {
00374 m_errno = ERROR_MSGSIZE;
00375 return -1;
00376 }
00377 if (!m_pendingData)
00378 {
00379 m_pendingData = new PendingData ();
00380 m_firstPendingSequence = m_nextTxSequence;
00381 }
00382
00383 m_pendingData->Add (p);
00384 NS_LOG_DEBUG("TcpSock::Send, pdsize " << m_pendingData->Size() <<
00385 " state " << m_state);
00386 Actions_t action = ProcessEvent (APP_SEND);
00387 NS_LOG_DEBUG(" action " << action);
00388 if (!ProcessAction (action))
00389 {
00390 return -1;
00391 }
00392 return p->GetSize();
00393 }
00394 else
00395 {
00396 m_errno = ERROR_NOTCONN;
00397 return -1;
00398 }
00399 }
00400
00401 int TcpSocketImpl::DoSendTo (Ptr<Packet> p, const Address &address)
00402 {
00403 NS_LOG_FUNCTION (this << p << address);
00404 InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
00405 Ipv4Address ipv4 = transport.GetIpv4 ();
00406 uint16_t port = transport.GetPort ();
00407 return DoSendTo (p, ipv4, port);
00408 }
00409
00410 int TcpSocketImpl::DoSendTo (Ptr<Packet> p, Ipv4Address ipv4, uint16_t port)
00411 {
00412 NS_LOG_FUNCTION (this << p << ipv4 << port);
00413 if (m_endPoint == 0)
00414 {
00415 if (Bind () == -1)
00416 {
00417 NS_ASSERT (m_endPoint == 0);
00418 return -1;
00419 }
00420 NS_ASSERT (m_endPoint != 0);
00421 }
00422 if (m_shutdownSend)
00423 {
00424 m_errno = ERROR_SHUTDOWN;
00425 return -1;
00426 }
00427 m_tcp->Send (p, m_endPoint->GetLocalAddress (), ipv4,
00428 m_endPoint->GetLocalPort (), port);
00429 NotifyDataSent (p->GetSize ());
00430 return 0;
00431 }
00432
00433 int
00434 TcpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
00435 {
00436 NS_LOG_FUNCTION (this << address << p);
00437 if (!m_connected)
00438 {
00439 m_errno = ERROR_NOTCONN;
00440 return -1;
00441 }
00442 else
00443 {
00444 return Send (p, flags);
00445 }
00446 }
00447
00448 uint32_t
00449 TcpSocketImpl::GetTxAvailable (void) const
00450 {
00451 NS_LOG_FUNCTION_NOARGS ();
00452 if (m_pendingData != 0)
00453 {
00454 uint32_t unAckedDataSize =
00455 m_pendingData->SizeFromSeq (m_firstPendingSequence, m_highestRxAck);
00456 NS_ASSERT (m_sndBufSize >= unAckedDataSize);
00457 return m_sndBufSize-unAckedDataSize;
00458 }
00459 else
00460 {
00461 return m_sndBufSize;
00462 }
00463 }
00464
00465 int
00466 TcpSocketImpl::Listen (void)
00467 {
00468 NS_LOG_FUNCTION (this);
00469
00470 if (m_state != CLOSED)
00471 {
00472 m_errno = ERROR_INVAL;
00473 return -1;
00474 }
00475 Actions_t action = ProcessEvent (APP_LISTEN);
00476 ProcessAction (action);
00477 return 0;
00478 }
00479
00480 Ptr<Packet>
00481 TcpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
00482 {
00483 NS_LOG_FUNCTION_NOARGS ();
00484 if(m_bufferedData.empty())
00485 {
00486 if(m_state == CLOSE_WAIT)
00487 {
00488 return Create<Packet>();
00489 }
00490
00491 return 0;
00492 }
00493 UnAckData_t out;
00494 UnAckData_t::iterator i;
00495 while (!m_bufferedData.empty ())
00496 {
00497 NS_LOG_LOGIC("TCP " << this << " bufferedData.size() "
00498 << m_bufferedData.size ()
00499 << " time " << Simulator::Now ());
00500 i = m_bufferedData.begin ();
00501 SequenceNumber s1 = 0;
00502 if (i->first > m_nextRxSequence)
00503 {
00504 break;
00505 }
00506 else
00507 {
00508
00509
00510 s1 = i->second->GetSize ();
00511 if (i->first + s1 > m_nextRxSequence)
00512 {
00513 uint32_t avail = s1 + i->first - m_nextRxSequence;
00514 i->second = i->second->CreateFragment (0, avail);
00515 }
00516
00517
00518 out[i->first] = i->second;
00519 }
00520 m_rxAvailable -= i->second->GetSize ();
00521 m_rxBufSize -= i->second->GetSize ();
00522 m_bufferedData.erase (i);
00523 }
00524 if (out.size() == 0)
00525 {
00526 return 0;
00527 }
00528 Ptr<Packet> outPacket = Create<Packet>();
00529 for(i = out.begin(); i!=out.end(); ++i)
00530 {
00531 if (outPacket->GetSize() + i->second->GetSize() <= maxSize )
00532 {
00533 outPacket->AddAtEnd(i->second);
00534 }
00535 else
00536 {
00537
00538 uint32_t avail = maxSize - outPacket->GetSize();
00539 outPacket->AddAtEnd(i->second->CreateFragment(0,avail));
00540
00541 m_bufferedData[i->first+SequenceNumber(avail)]
00542 = i->second->CreateFragment(avail,i->second->GetSize()-avail);
00543 m_rxAvailable += i->second->GetSize()-avail;
00544 m_rxBufSize += i->second->GetSize()-avail;
00545 }
00546 }
00547 return outPacket;
00548 }
00549
00550 uint32_t
00551 TcpSocketImpl::GetRxAvailable (void) const
00552 {
00553 NS_LOG_FUNCTION_NOARGS ();
00554
00555
00556 return m_rxAvailable;
00557 }
00558
00559 Ptr<Packet>
00560 TcpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
00561 Address &fromAddress)
00562 {
00563 NS_LOG_FUNCTION (this << maxSize << flags);
00564 Ptr<Packet> packet = Recv (maxSize, flags);
00565
00566 if (packet != 0 && packet->GetSize() != 0)
00567 {
00568 SocketAddressTag tag;
00569 bool found;
00570 found = packet->FindFirstMatchingTag (tag);
00571 NS_ASSERT (found);
00572 fromAddress = tag.GetAddress ();
00573 }
00574 return packet;
00575 }
00576
00577 int
00578 TcpSocketImpl::GetSockName (Address &address) const
00579 {
00580 NS_LOG_FUNCTION_NOARGS ();
00581 address = InetSocketAddress(m_localAddress, m_localPort);
00582 return 0;
00583 }
00584
00585 void
00586 TcpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)
00587 {
00588 NS_LOG_DEBUG("Socket " << this << " got forward up" <<
00589 " dport " << m_endPoint->GetLocalPort() <<
00590 " daddr " << m_endPoint->GetLocalAddress() <<
00591 " sport " << m_endPoint->GetPeerPort() <<
00592 " saddr " << m_endPoint->GetPeerAddress());
00593
00594 NS_LOG_FUNCTION (this << packet << ipv4 << port);
00595 if (m_shutdownRecv)
00596 {
00597 return;
00598 }
00599 TcpHeader tcpHeader;
00600 packet->RemoveHeader (tcpHeader);
00601
00602 if (tcpHeader.GetFlags () & TcpHeader::ACK)
00603 {
00604 Time m = m_rtt->AckSeq (tcpHeader.GetAckNumber () );
00605 if (m != Seconds (0.0))
00606 {
00607 m_lastMeasuredRtt = m;
00608 }
00609 }
00610
00611 if (m_rxWindowSize == 0 && tcpHeader.GetWindowSize () != 0)
00612 {
00613 NS_LOG_LOGIC (this<<" Leaving zerowindow persist state");
00614 m_persistEvent.Cancel ();
00615 }
00616 m_rxWindowSize = tcpHeader.GetWindowSize ();
00617
00618 Events_t event = SimulationSingleton<TcpStateMachine>::Get ()->FlagsEvent (tcpHeader.GetFlags () );
00619 Actions_t action = ProcessEvent (event);
00620 Address address = InetSocketAddress (ipv4, port);
00621 NS_LOG_DEBUG("Socket " << this <<
00622 " processing pkt action, " << action <<
00623 " current state " << m_state);
00624 ProcessPacketAction (action, packet, tcpHeader, address);
00625 }
00626
00627 Actions_t TcpSocketImpl::ProcessEvent (Events_t e)
00628 {
00629 NS_LOG_FUNCTION (this << e);
00630 States_t saveState = m_state;
00631 NS_LOG_LOGIC ("TcpSocketImpl " << this << " processing event " << e);
00632
00633
00634 SA stateAction = SimulationSingleton<TcpStateMachine>::Get ()->Lookup (m_state,e);
00635
00636 if (stateAction.action == RST_TX)
00637 {
00638 NS_LOG_LOGIC ("TcpSocketImpl " << this << " sending RST from state "
00639 << saveState << " event " << e);
00640 }
00641 bool needCloseNotify = (stateAction.state == CLOSED && m_state != CLOSED
00642 && e != TIMEOUT);
00643 m_state = stateAction.state;
00644 NS_LOG_LOGIC ("TcpSocketImpl " << this << " moved from state " << saveState
00645 << " to state " <<m_state);
00646 NS_LOG_LOGIC ("TcpSocketImpl " << this << " pendingData " << m_pendingData);
00647
00648
00649
00650 if (saveState == SYN_SENT && m_state == ESTABLISHED)
00651
00652
00653 {
00654 Simulator::ScheduleNow(&TcpSocketImpl::ConnectionSucceeded, this);
00655
00656 m_connected = true;
00657 m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
00658 NS_LOG_LOGIC ("TcpSocketImpl " << this << " Connected!");
00659 }
00660
00661 if (needCloseNotify && !m_closeNotified)
00662 {
00663 NS_LOG_LOGIC ("TcpSocketImpl " << this << " transition to CLOSED from "
00664 << m_state << " event " << e << " closeNot " << m_closeNotified
00665 << " action " << stateAction.action);
00666 m_closeNotified = true;
00667 NS_LOG_LOGIC ("TcpSocketImpl " << this << " calling Closed from PE"
00668 << " origState " << saveState
00669 << " event " << e);
00670 NS_LOG_LOGIC ("TcpSocketImpl " << this << " transition to CLOSED from "
00671 << m_state << " event " << e
00672 << " set CloseNotif ");
00673 }
00674 return stateAction.action;
00675 }
00676
00677 void TcpSocketImpl::SendEmptyPacket (uint8_t flags)
00678 {
00679 NS_LOG_FUNCTION (this << (uint32_t)flags);
00680 Ptr<Packet> p = Create<Packet> ();
00681 TcpHeader header;
00682
00683 header.SetFlags (flags);
00684 header.SetSequenceNumber (m_nextTxSequence);
00685 header.SetAckNumber (m_nextRxSequence);
00686 header.SetSourcePort (m_endPoint->GetLocalPort ());
00687 header.SetDestinationPort (m_remotePort);
00688 header.SetWindowSize (AdvertisedWindowSize());
00689 m_tcp->SendPacket (p, header, m_endPoint->GetLocalAddress (),
00690 m_remoteAddress);
00691 Time rto = m_rtt->RetransmitTimeout ();
00692 bool hasSyn = flags & TcpHeader::SYN;
00693 bool hasFin = flags & TcpHeader::FIN;
00694 bool isAck = flags == TcpHeader::ACK;
00695 if (hasSyn)
00696 {
00697 rto = m_cnTimeout;
00698 m_cnTimeout = m_cnTimeout + m_cnTimeout;
00699 m_cnCount--;
00700 }
00701 if (m_retxEvent.IsExpired () && (hasSyn || hasFin) && !isAck )
00702
00703 {
00704 NS_LOG_LOGIC ("Schedule retransmission timeout at time "
00705 << Simulator::Now ().GetSeconds () << " to expire at time "
00706 << (Simulator::Now () + rto).GetSeconds ());
00707 m_retxEvent = Simulator::Schedule (rto, &TcpSocketImpl::ReTxTimeout, this);
00708 }
00709 }
00710
00711 bool TcpSocketImpl::ProcessAction (Actions_t a)
00712 {
00713 NS_LOG_FUNCTION (this << a);
00714 switch (a)
00715 {
00716 case NO_ACT:
00717 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action: NO_ACT");
00718 break;
00719 case ACK_TX:
00720 SendEmptyPacket (TcpHeader::ACK);
00721 break;
00722 case ACK_TX_1:
00723 NS_ASSERT (false);
00724 break;
00725 case RST_TX:
00726 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action RST_TX");
00727 SendEmptyPacket (TcpHeader::RST);
00728 break;
00729 case SYN_TX:
00730 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action SYN_TX");
00731
00732
00733
00734
00735 SendEmptyPacket (TcpHeader::SYN);
00736 break;
00737 case SYN_ACK_TX:
00738 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action SYN_ACK_TX");
00739
00740 ++m_nextRxSequence;
00741 SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
00742 break;
00743 case FIN_TX:
00744 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action FIN_TX");
00745 SendEmptyPacket (TcpHeader::FIN);
00746 break;
00747 case FIN_ACK_TX:
00748 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action FIN_ACK_TX");
00749 SendEmptyPacket (TcpHeader::FIN | TcpHeader::ACK);
00750 break;
00751 case NEW_ACK:
00752 NS_ASSERT (false);
00753 break;
00754 case NEW_SEQ_RX:
00755 NS_ASSERT (false);
00756 break;
00757 case RETX:
00758 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action RETX");
00759 break;
00760 case TX_DATA:
00761 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action TX_DATA");
00762 SendPendingData ();
00763 break;
00764 case PEER_CLOSE:
00765 NS_ASSERT (false);
00766 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action PEER_CLOSE");
00767 break;
00768 case APP_CLOSED:
00769 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action APP_CLOSED");
00770 break;
00771 case CANCEL_TM:
00772 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action CANCEL_TM");
00773 break;
00774 case APP_NOTIFY:
00775 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action APP_NOTIFY");
00776 break;
00777 case SERV_NOTIFY:
00778 NS_ASSERT (false);
00779 break;
00780 case LAST_ACTION:
00781 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action LAST_ACTION");
00782 break;
00783 }
00784 return true;
00785 }
00786
00787 bool TcpSocketImpl::ProcessPacketAction (Actions_t a, Ptr<Packet> p,
00788 const TcpHeader& tcpHeader,
00789 const Address& fromAddress)
00790 {
00791 NS_LOG_FUNCTION (this << a << p << fromAddress);
00792 uint32_t localIfIndex;
00793 Ptr<Ipv4> ipv4 = m_node->GetObject<Ipv4> ();
00794 switch (a)
00795 {
00796 case ACK_TX:
00797 if(tcpHeader.GetFlags() & TcpHeader::FIN)
00798 {
00799 ++m_nextRxSequence;
00800 }
00801 SendEmptyPacket (TcpHeader::ACK);
00802 break;
00803 case SYN_ACK_TX:
00804 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action SYN_ACK_TX");
00805
00806
00807
00808
00809
00810
00811 if (m_state == LISTEN)
00812 {
00813 NS_LOG_DEBUG("In SYN_ACK_TX, m_state is LISTEN, this " << this);
00814
00815
00816 if (!NotifyConnectionRequest(fromAddress)) return true;
00817
00818 Ptr<TcpSocketImpl> newSock = Copy ();
00819 NS_LOG_LOGIC ("Cloned a TcpSocketImpl " << newSock);
00820
00821 Simulator::ScheduleNow (&TcpSocketImpl::CompleteFork, newSock,
00822 p, tcpHeader,fromAddress);
00823 return true;
00824 }
00825
00826 NS_ASSERT (m_state == SYN_RCVD);
00827 m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
00828 if (ipv4->GetIfIndexForDestination (m_remoteAddress, localIfIndex))
00829 {
00830 m_localAddress = ipv4->GetAddress (localIfIndex);
00831 m_endPoint->SetLocalAddress (m_localAddress);
00832
00833
00834
00835 }
00836
00837 m_nextRxSequence = tcpHeader.GetSequenceNumber() + SequenceNumber(1);
00838 SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
00839 break;
00840 case ACK_TX_1:
00841 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action ACK_TX_1");
00842
00843 m_nextRxSequence = tcpHeader.GetSequenceNumber() + SequenceNumber(1);
00844 m_nextTxSequence = tcpHeader.GetAckNumber ();
00845 m_firstPendingSequence = m_nextTxSequence;
00846 NS_LOG_DEBUG ("TcpSocketImpl " << this << " ACK_TX_1" <<
00847 " nextRxSeq " << m_nextRxSequence);
00848 SendEmptyPacket (TcpHeader::ACK);
00849 if (tcpHeader.GetAckNumber () > m_highestRxAck)
00850 {
00851 m_highestRxAck = tcpHeader.GetAckNumber ();
00852
00853 if (GetTxAvailable () > 0)
00854 {
00855 NotifySend (GetTxAvailable ());
00856 }
00857 }
00858 SendPendingData ();
00859 break;
00860 case NEW_ACK:
00861 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action NEW_ACK_TX");
00862 if (tcpHeader.GetAckNumber () < m_highestRxAck)
00863 {
00864 break;
00865 }
00866 if (tcpHeader.GetAckNumber () == m_highestRxAck)
00867 {
00868 if (tcpHeader.GetAckNumber () < m_nextTxSequence)
00869 {
00870 DupAck (tcpHeader, ++m_dupAckCount);
00871 }
00872 NS_ASSERT(tcpHeader.GetAckNumber () <= m_nextTxSequence);
00873
00874 break;
00875 }
00876 if (tcpHeader.GetAckNumber () > m_highestRxAck)
00877 {
00878 m_dupAckCount = 0;
00879 }
00880 NewAck (tcpHeader.GetAckNumber ());
00881 break;
00882 case NEW_SEQ_RX:
00883 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action NEW_SEQ_RX");
00884 NewRx (p, tcpHeader, fromAddress);
00885 break;
00886 case PEER_CLOSE:
00887 {
00888
00889
00890
00891 if (tcpHeader.GetSequenceNumber () != m_nextRxSequence)
00892 {
00893 m_pendingClose = true;
00894 NS_LOG_LOGIC ("TcpSocketImpl " << this << " setting pendingClose"
00895 << " rxseq " << tcpHeader.GetSequenceNumber ()
00896 << " nextRxSeq " << m_nextRxSequence);
00897 NewRx (p, tcpHeader, fromAddress);
00898 return true;
00899 }
00900
00901
00902 if (p->GetSize () != 0)
00903 {
00904 NewRx (p, tcpHeader, fromAddress);
00905 }
00906 ++m_nextRxSequence;
00907 States_t saveState = m_state;
00908 NS_LOG_LOGIC ("TcpSocketImpl " << this
00909 << " peer close, state " << m_state);
00910 if (!m_closeRequestNotified)
00911 {
00912 NS_LOG_LOGIC ("TCP " << this
00913 << " calling AppCloseRequest");
00914 m_closeRequestNotified = true;
00915 }
00916 NS_LOG_LOGIC ("TcpSocketImpl " << this
00917 << " peer close, state after " << m_state);
00918 if (m_state == saveState)
00919 {
00920 SendEmptyPacket (TcpHeader::ACK);
00921
00922 }
00923 if (m_state == LAST_ACK)
00924 {
00925 NS_LOG_LOGIC ("TcpSocketImpl " << this << " scheduling LATO1");
00926 m_lastAckEvent = Simulator::Schedule (m_rtt->RetransmitTimeout (),
00927 &TcpSocketImpl::LastAckTimeout,this);
00928 }
00929 break;
00930 }
00931 case SERV_NOTIFY:
00932 NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action SERV_NOTIFY");
00933 NS_LOG_LOGIC ("TcpSocketImpl " << this << " Connected!");
00934 m_connected = true;
00935 m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
00936
00937 CommonNewAck (tcpHeader.GetAckNumber (), true);
00938 NotifyNewConnectionCreated (this, fromAddress);
00939 break;
00940 default:
00941 return ProcessAction (a);
00942 }
00943 return true;
00944 }
00945
00946 void TcpSocketImpl::CompleteFork(Ptr<Packet> p, const TcpHeader& h, const Address& fromAddress)
00947 {
00948
00949 m_remotePort = InetSocketAddress::ConvertFrom (fromAddress).GetPort ();
00950 m_remoteAddress = InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 ();
00951 m_endPoint = m_tcp->Allocate (m_localAddress,
00952 m_localPort,
00953 m_remoteAddress,
00954 m_remotePort);
00955
00956 m_state = SYN_RCVD;
00957
00958 m_endPoint->SetRxCallback (MakeCallback (&TcpSocketImpl::ForwardUp, Ptr<TcpSocketImpl>(this)));
00959 m_endPoint->SetDestroyCallback (MakeCallback (&TcpSocketImpl::Destroy, Ptr<TcpSocketImpl>(this)));
00960 ProcessPacketAction(SYN_ACK_TX, p, h, fromAddress);
00961 }
00962
00963 void TcpSocketImpl::ConnectionSucceeded()
00964 {
00965
00966
00967 NotifyConnectionSucceeded();
00968 }
00969
00970 bool TcpSocketImpl::SendPendingData (bool withAck)
00971 {
00972 NS_LOG_FUNCTION (this << withAck);
00973 NS_LOG_LOGIC ("ENTERING SendPendingData");
00974 if (!m_pendingData)
00975 {
00976 return false;
00977 }
00978 uint32_t nPacketsSent = 0;
00979 while (m_pendingData->SizeFromSeq (m_firstPendingSequence, m_nextTxSequence))
00980 {
00981 uint32_t w = AvailableWindow ();
00982 NS_LOG_LOGIC ("TcpSocketImpl " << this << " SendPendingData"
00983 << " w " << w
00984 << " rxwin " << m_rxWindowSize
00985 << " cWnd " << m_cWnd
00986 << " segsize " << m_segmentSize
00987 << " nextTxSeq " << m_nextTxSequence
00988 << " highestRxAck " << m_highestRxAck
00989 << " pd->Size " << m_pendingData->Size ()
00990 << " pd->SFS " << m_pendingData->SizeFromSeq (m_firstPendingSequence, m_nextTxSequence));
00991
00992 if (w < m_segmentSize && m_pendingData->Size () > w)
00993 {
00994 break;
00995 }
00996 uint32_t s = std::min (w, m_segmentSize);
00997 Ptr<Packet> p = m_pendingData->CopyFromSeq (s, m_firstPendingSequence,
00998 m_nextTxSequence);
00999 NS_LOG_LOGIC("TcpSocketImpl " << this << " SendPendingData"
01000 << " txseq " << m_nextTxSequence
01001 << " s " << s
01002 << " datasize " << p->GetSize() );
01003 uint8_t flags = 0;
01004 if (withAck)
01005 {
01006 flags |= TcpHeader::ACK;
01007 }
01008 uint32_t sz = p->GetSize ();
01009 uint32_t remainingData = m_pendingData->SizeFromSeq(
01010 m_firstPendingSequence,
01011 m_nextTxSequence + SequenceNumber (sz));
01012 if (m_closeOnEmpty && (remainingData == 0))
01013 {
01014 flags = TcpHeader::FIN;
01015 m_state = FIN_WAIT_1;
01016 }
01017
01018 TcpHeader header;
01019 header.SetFlags (flags);
01020 header.SetSequenceNumber (m_nextTxSequence);
01021 header.SetAckNumber (m_nextRxSequence);
01022 header.SetSourcePort (m_endPoint->GetLocalPort());
01023 header.SetDestinationPort (m_remotePort);
01024 header.SetWindowSize (AdvertisedWindowSize());
01025 if (m_shutdownSend)
01026 {
01027 m_errno = ERROR_SHUTDOWN;
01028 return -1;
01029 }
01030
01031
01032 if (m_retxEvent.IsExpired () )
01033 {
01034 Time rto = m_rtt->RetransmitTimeout ();
01035 NS_LOG_LOGIC (this<<" SendPendingData Schedule ReTxTimeout at time " <<
01036 Simulator::Now ().GetSeconds () << " to expire at time " <<
01037 (Simulator::Now () + rto).GetSeconds () );
01038 m_retxEvent = Simulator::Schedule (rto,&TcpSocketImpl::ReTxTimeout,this);
01039 }
01040 NS_LOG_LOGIC ("About to send a packet with flags: " << flags);
01041 m_tcp->SendPacket (p, header,
01042 m_endPoint->GetLocalAddress (),
01043 m_remoteAddress);
01044 m_rtt->SentSeq(m_nextTxSequence, sz);
01045
01046 Simulator::ScheduleNow(&TcpSocketImpl::NotifyDataSent, this, p->GetSize ());
01047 nPacketsSent++;
01048 m_nextTxSequence += sz;
01049
01050 m_highTxMark = std::max (m_nextTxSequence, m_highTxMark);
01051 }
01052 NS_LOG_LOGIC ("SendPendingData Sent "<<nPacketsSent<<" packets");
01053 NS_LOG_LOGIC("RETURN SendPendingData");
01054 return (nPacketsSent>0);
01055 }
01056
01057 uint32_t TcpSocketImpl::UnAckDataCount ()
01058 {
01059 NS_LOG_FUNCTION_NOARGS ();
01060 return m_nextTxSequence - m_highestRxAck;
01061 }
01062
01063 uint32_t TcpSocketImpl::BytesInFlight ()
01064 {
01065 NS_LOG_FUNCTION_NOARGS ();
01066 return m_highTxMark - m_highestRxAck;
01067 }
01068
01069 uint32_t TcpSocketImpl::Window ()
01070 {
01071 NS_LOG_FUNCTION_NOARGS ();
01072 NS_LOG_LOGIC ("TcpSocketImpl::Window() "<<this);
01073 return std::min (m_rxWindowSize, m_cWnd.Get());
01074 }
01075
01076 uint32_t TcpSocketImpl::AvailableWindow ()
01077 {
01078 NS_LOG_FUNCTION_NOARGS ();
01079 uint32_t unack = UnAckDataCount ();
01080 uint32_t win = Window ();
01081 if (win < unack)
01082 {
01083 return 0;
01084 }
01085 return (win - unack);
01086 }
01087
01088 uint32_t TcpSocketImpl::RxBufferFreeSpace()
01089 {
01090 return m_rxBufMaxSize - m_rxBufSize;
01091 }
01092
01093 uint16_t TcpSocketImpl::AdvertisedWindowSize()
01094 {
01095 uint32_t max = 0xffff;
01096 return std::min(RxBufferFreeSpace(), max);
01097 }
01098
01099 void TcpSocketImpl::NewRx (Ptr<Packet> p,
01100 const TcpHeader& tcpHeader,
01101 const Address& fromAddress)
01102 {
01103 NS_LOG_FUNCTION (this << p << "tcpHeader " << fromAddress);
01104 NS_LOG_LOGIC ("TcpSocketImpl " << this << " NewRx,"
01105 << " seq " << tcpHeader.GetSequenceNumber()
01106 << " ack " << tcpHeader.GetAckNumber()
01107 << " p.size is " << p->GetSize () );
01108 NS_LOG_DEBUG ("TcpSocketImpl " << this <<
01109 " NewRx," <<
01110 " seq " << tcpHeader.GetSequenceNumber() <<
01111 " ack " << tcpHeader.GetAckNumber() <<
01112 " p.size is " << p->GetSize());
01113 States_t origState = m_state;
01114 if (RxBufferFreeSpace() < p->GetSize())
01115 {
01116 p = p->CreateFragment(0, RxBufferFreeSpace());
01117 }
01118
01119
01120
01121
01122
01123
01124 uint32_t s = p->GetSize ();
01125 if (s == 0)
01126 {
01127 SendEmptyPacket (TcpHeader::ACK);
01128 return;
01129 }
01130
01131
01132
01133
01134
01135
01136 if (tcpHeader.GetSequenceNumber () == m_nextRxSequence)
01137 {
01138
01139
01140
01141
01142 UnAckData_t::iterator next = m_bufferedData.upper_bound (m_nextRxSequence);
01143 if (next != m_bufferedData.end ())
01144 {
01145 SequenceNumber nextBufferedSeq = next->first;
01146 if (m_nextRxSequence + SequenceNumber(s) > nextBufferedSeq)
01147 {
01148 s = nextBufferedSeq - m_nextRxSequence;
01149 }
01150 }
01151 p = p->CreateFragment (0,s);
01152 m_nextRxSequence += s;
01153 NS_LOG_LOGIC("Case 1, advanced nrxs to " << m_nextRxSequence );
01154 SocketAddressTag tag;
01155 tag.SetAddress (fromAddress);
01156 p->AddTag (tag);
01157
01158 UnAckData_t::iterator i =
01159 m_bufferedData.find (tcpHeader.GetSequenceNumber () );
01160 NS_ASSERT(i == m_bufferedData.end ());
01161
01162 m_bufferedData[tcpHeader.GetSequenceNumber () ] = p;
01163 m_rxAvailable += p->GetSize ();
01164 RxBufFinishInsert (tcpHeader.GetSequenceNumber ());
01165 m_rxBufSize += p->GetSize ();
01166 NotifyDataRecv ();
01167 if (m_closeNotified)
01168 {
01169 NS_LOG_LOGIC ("Tcp " << this << " HuH? Got data after closeNotif");
01170 }
01171 NS_LOG_LOGIC ("TcpSocketImpl " << this << " adv rxseq by " << s);
01172 if (m_pendingClose || (origState > ESTABLISHED))
01173 {
01174 if (m_bufferedData.empty())
01175 {
01176 ProcessPacketAction (PEER_CLOSE, p, tcpHeader, fromAddress);
01177 }
01178 }
01179 }
01180 else if (tcpHeader.GetSequenceNumber () > m_nextRxSequence)
01181 {
01182 NS_LOG_LOGIC ("Case 2, buffering " << tcpHeader.GetSequenceNumber () );
01183 UnAckData_t::iterator previous =
01184 m_bufferedData.lower_bound (tcpHeader.GetSequenceNumber ());
01185 SequenceNumber startSeq = tcpHeader.GetSequenceNumber();
01186 if (previous != m_bufferedData.begin ())
01187 {
01188 --previous;
01189 startSeq = previous->first + SequenceNumber(previous->second->GetSize());
01190 if (startSeq > tcpHeader.GetSequenceNumber ())
01191 {
01192 s = tcpHeader.GetSequenceNumber () + SequenceNumber(s) - startSeq;
01193 }
01194 else
01195 {
01196 startSeq = tcpHeader.GetSequenceNumber();
01197 }
01198 }
01199
01200 UnAckData_t::iterator next = m_bufferedData.upper_bound (tcpHeader.GetSequenceNumber());
01201 if (next != m_bufferedData.end ())
01202 {
01203 SequenceNumber nextBufferedSeq = next->first;
01204 if (startSeq + SequenceNumber(s) > nextBufferedSeq)
01205 {
01206 s = nextBufferedSeq - startSeq;
01207 }
01208 }
01209 p = p->CreateFragment (startSeq - tcpHeader.GetSequenceNumber (),s);
01210 UnAckData_t::iterator i =
01211 m_bufferedData.find (startSeq);
01212 if (i != m_bufferedData.end () )
01213 {
01214 if(p->GetSize() > i->second->GetSize())
01215 {
01216 i->second = 0;
01217 }
01218 else
01219 {
01220 p = i->second;
01221 }
01222 }
01223
01224 SocketAddressTag tag;
01225 tag.SetAddress (fromAddress);
01226 p->AddTag (tag);
01227 m_bufferedData[startSeq] = p;
01228 i = m_bufferedData.find (startSeq);
01229 next = i;
01230 ++next;
01231 if(next != m_bufferedData.end())
01232 {
01233 NS_ASSERT(next->first >= i->first + SequenceNumber(i->second->GetSize ()));
01234 }
01235 }
01236 else if (tcpHeader.GetSequenceNumber () + SequenceNumber(s) > m_nextRxSequence)
01237 {
01238
01239 s = tcpHeader.GetSequenceNumber () + SequenceNumber(s) - m_nextRxSequence;
01240
01241 UnAckData_t::iterator next = m_bufferedData.upper_bound (m_nextRxSequence);
01242 if (next != m_bufferedData.end ())
01243 {
01244 SequenceNumber nextBufferedSeq = next->first;
01245 if (m_nextRxSequence + SequenceNumber(s) > nextBufferedSeq)
01246 {
01247 s = nextBufferedSeq - m_nextRxSequence;
01248 }
01249 }
01250 p = p->CreateFragment (m_nextRxSequence - tcpHeader.GetSequenceNumber (),s);
01251 SequenceNumber start = m_nextRxSequence;
01252 m_nextRxSequence += s;
01253 SocketAddressTag tag;
01254 tag.SetAddress (fromAddress);
01255 p->AddTag (tag);
01256
01257 UnAckData_t::iterator i = m_bufferedData.find (start);
01258 if (i != m_bufferedData.end () )
01259 {
01260 i->second = 0;
01261 }
01262
01263 m_bufferedData[start] = p;
01264 m_rxAvailable += p->GetSize ();
01265 m_rxBufSize += p->GetSize();
01266 RxBufFinishInsert(start);
01267 NotifyDataRecv ();
01268 }
01269 else
01270 {
01271 NS_LOG_LOGIC("TCP " << this
01272 << " got seq " << tcpHeader.GetSequenceNumber ()
01273 << " expected " << m_nextRxSequence
01274 << " flags " << tcpHeader.GetFlags ());
01275 }
01276
01277 if(++m_delAckCount >= m_delAckMaxCount)
01278 {
01279 m_delAckEvent.Cancel();
01280 m_delAckCount = 0;
01281 SendEmptyPacket (TcpHeader::ACK);
01282 }
01283 else
01284 {
01285 if (m_delAckEvent.IsExpired())
01286 {
01287 m_delAckEvent = Simulator::Schedule (m_delAckTimeout, &TcpSocketImpl::DelAckTimeout, this);
01288 }
01289 }
01290 }
01291
01292 void TcpSocketImpl::RxBufFinishInsert (SequenceNumber seq)
01293 {
01294
01295
01296
01297 UnAckData_t::iterator i = m_bufferedData.find (seq);
01298 UnAckData_t::iterator next = i;
01299 ++next;
01300
01301 if(next != m_bufferedData.end())
01302 {
01303 NS_ASSERT(next->first >= i->first + SequenceNumber(i->second->GetSize ()));
01304 }
01305 while(next != m_bufferedData.end())
01306 {
01307 if(i->first + SequenceNumber(i->second->GetSize ()) == next->first)
01308 {
01309
01310 m_rxAvailable += next->second->GetSize();
01311 m_nextRxSequence += next->second->GetSize();
01312 }
01313 else
01314 {
01315 break;
01316 }
01317 ++i;
01318 ++next;
01319 }
01320 }
01321
01322 void TcpSocketImpl::DelAckTimeout ()
01323 {
01324 m_delAckCount = 0;
01325 SendEmptyPacket (TcpHeader::ACK);
01326 }
01327
01328 void TcpSocketImpl::CommonNewAck (SequenceNumber ack, bool skipTimer)
01329 {
01330
01331
01332 NS_LOG_FUNCTION (this << ack << skipTimer);
01333
01334 if (!skipTimer)
01335 {
01336 NS_LOG_LOGIC (this<<" Cancelled ReTxTimeout event which was set to expire at "
01337 << (Simulator::Now () +
01338 Simulator::GetDelayLeft (m_retxEvent)).GetSeconds());
01339 m_retxEvent.Cancel ();
01340
01341 Time rto = m_rtt->RetransmitTimeout ();
01342 NS_LOG_LOGIC (this<<" Schedule ReTxTimeout at time "
01343 << Simulator::Now ().GetSeconds () << " to expire at time "
01344 << (Simulator::Now () + rto).GetSeconds ());
01345 m_retxEvent =
01346 Simulator::Schedule (rto, &TcpSocketImpl::ReTxTimeout, this);
01347 }
01348 if (m_rxWindowSize == 0 && m_persistEvent.IsExpired ())
01349 {
01350 NS_LOG_LOGIC (this<<"Enter zerowindow persist state");
01351 NS_LOG_LOGIC (this<<" Cancelled ReTxTimeout event which was set to expire at "
01352 << (Simulator::Now () +
01353 Simulator::GetDelayLeft (m_retxEvent)).GetSeconds());
01354 m_retxEvent.Cancel ();
01355 NS_LOG_LOGIC ("Schedule persist timeout at time "
01356 <<Simulator::Now ().GetSeconds () << " to expire at time "
01357 << (Simulator::Now () + m_persistTime).GetSeconds());
01358 m_persistEvent =
01359 Simulator::Schedule (m_persistTime, &TcpSocketImpl::PersistTimeout, this);
01360 NS_ASSERT (m_persistTime == Simulator::GetDelayLeft (m_persistEvent));
01361 }
01362 NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack
01363 << " numberAck " << (ack - m_highestRxAck));
01364 m_highestRxAck = ack;
01365 if (GetTxAvailable () > 0)
01366 {
01367 NotifySend (GetTxAvailable ());
01368 }
01369 if (ack > m_nextTxSequence)
01370 {
01371 m_nextTxSequence = ack;
01372 }
01373
01374 if (m_pendingData)
01375 {
01376 if (m_pendingData->SizeFromSeq (m_firstPendingSequence, m_highestRxAck) == 0)
01377 {
01378 m_pendingData->Clear ();
01379 delete m_pendingData;
01380 m_pendingData = 0;
01381
01382 NS_LOG_LOGIC (this<<" Cancelled ReTxTimeout event which was set to expire at "
01383 << (Simulator::Now () +
01384 Simulator::GetDelayLeft (m_retxEvent)).GetSeconds());
01385 m_retxEvent.Cancel ();
01386 }
01387 }
01388
01389 SendPendingData();
01390 }
01391
01392 Ptr<TcpSocketImpl> TcpSocketImpl::Copy ()
01393 {
01394 return CopyObject<TcpSocketImpl> (this);
01395 }
01396
01397 void TcpSocketImpl::NewAck (SequenceNumber seq)
01398 {
01399
01400 NS_LOG_FUNCTION (this << seq);
01401 NS_LOG_LOGIC ("TcpSocketImpl " << this << " NewAck "
01402 << " seq " << seq
01403 << " cWnd " << m_cWnd
01404 << " ssThresh " << m_ssThresh);
01405 if (m_cWnd < m_ssThresh)
01406 {
01407 m_cWnd += m_segmentSize;
01408 NS_LOG_LOGIC ("TcpSocketImpl " << this << " NewCWnd SlowStart, cWnd " << m_cWnd
01409 << " sst " << m_ssThresh);
01410 }
01411 else
01412 {
01413 double adder = ((double) m_segmentSize * m_segmentSize) / m_cWnd.Get();
01414 if (adder < 1.0)
01415 {
01416 adder = 1.0;
01417 }
01418 m_cWnd += (uint32_t) adder;
01419 NS_LOG_LOGIC ("NewCWnd CongAvoid, cWnd " << m_cWnd
01420 << " sst " << m_ssThresh);
01421 }
01422 CommonNewAck (seq, false);
01423 }
01424
01425 void TcpSocketImpl::DupAck (const TcpHeader& t, uint32_t count)
01426 {
01427 NS_LOG_FUNCTION (this << "t " << count);
01428 NS_LOG_LOGIC ("TcpSocketImpl " << this << " DupAck " << t.GetAckNumber ()
01429 << ", count " << count
01430 << ", time " << Simulator::Now ());
01431 if (count == 3)
01432 {
01433 m_ssThresh = Window () / 2;
01434 m_ssThresh = std::max (m_ssThresh, 2 * m_segmentSize);
01435 NS_LOG_LOGIC("TcpSocketImpl " << this << "Tahoe TDA, time " << Simulator::Now ()
01436 << " seq " << t.GetAckNumber ()
01437 << " in flight " << BytesInFlight ()
01438 << " new ssthresh " << m_ssThresh);
01439
01440 m_cWnd = m_segmentSize;
01441
01442 m_nextTxSequence = m_highestRxAck;
01443 SendPendingData ();
01444 }
01445 }
01446
01447 void TcpSocketImpl::ReTxTimeout ()
01448 {
01449 NS_LOG_FUNCTION (this);
01450 NS_LOG_LOGIC (this<<" ReTxTimeout Expired at time "<<Simulator::Now ().GetSeconds());
01451 m_ssThresh = Window () / 2;
01452 m_ssThresh = std::max (m_ssThresh, 2 * m_segmentSize);
01453
01454
01455 m_cWnd = m_segmentSize;
01456 m_nextTxSequence = m_highestRxAck;
01457 m_rtt->IncreaseMultiplier ();
01458 Retransmit ();
01459 }
01460
01461 void TcpSocketImpl::LastAckTimeout ()
01462 {
01463 m_lastAckEvent.Cancel ();
01464 if (m_state == LAST_ACK)
01465 {
01466 Actions_t action = ProcessEvent (TIMEOUT);
01467 ProcessAction (action);
01468 }
01469 if (!m_closeNotified)
01470 {
01471 m_closeNotified = true;
01472 }
01473 }
01474
01475 void TcpSocketImpl::PersistTimeout ()
01476 {
01477 NS_LOG_LOGIC ("PersistTimeout expired at "<<Simulator::Now ().GetSeconds ());
01478 m_persistTime = Scalar(2)*m_persistTime;
01479 m_persistTime = std::min(Seconds(60),m_persistTime);
01480
01481
01482 Ptr<Packet> p =
01483 m_pendingData->CopyFromSeq(1,m_firstPendingSequence,m_nextTxSequence);
01484 TcpHeader tcpHeader;
01485 tcpHeader.SetSequenceNumber (m_nextTxSequence);
01486 tcpHeader.SetAckNumber (m_nextRxSequence);
01487 tcpHeader.SetSourcePort (m_endPoint->GetLocalPort());
01488 tcpHeader.SetDestinationPort (m_remotePort);
01489 tcpHeader.SetWindowSize (AdvertisedWindowSize());
01490
01491 m_tcp->SendPacket (p, tcpHeader, m_endPoint->GetLocalAddress (),
01492 m_remoteAddress);
01493 NS_LOG_LOGIC ("Schedule persist timeout at time "
01494 <<Simulator::Now ().GetSeconds () << " to expire at time "
01495 << (Simulator::Now () + m_persistTime).GetSeconds());
01496 m_persistEvent =
01497 Simulator::Schedule (m_persistTime, &TcpSocketImpl::PersistTimeout, this);
01498 }
01499
01500 void TcpSocketImpl::Retransmit ()
01501 {
01502 NS_LOG_FUNCTION (this);
01503 uint8_t flags = TcpHeader::NONE;
01504 if (m_state == SYN_SENT)
01505 {
01506 if (m_cnCount > 0)
01507 {
01508 SendEmptyPacket (TcpHeader::SYN);
01509 return;
01510 }
01511 else
01512 {
01513 NotifyConnectionFailed ();
01514 return;
01515 }
01516 }
01517 if (!m_pendingData)
01518 {
01519 if (m_state == FIN_WAIT_1)
01520 {
01521 SendEmptyPacket (TcpHeader::FIN);
01522 }
01523 return;
01524 }
01525 NS_ASSERT(m_nextTxSequence == m_highestRxAck);
01526 Ptr<Packet> p = m_pendingData->CopyFromSeq (m_segmentSize,
01527 m_firstPendingSequence,
01528 m_nextTxSequence);
01529
01530 uint32_t remainingData = m_pendingData->SizeFromSeq (
01531 m_firstPendingSequence,
01532 m_nextTxSequence + SequenceNumber(p->GetSize ()));
01533 if (m_closeOnEmpty && remainingData == 0)
01534 {
01535 flags = flags | TcpHeader::FIN;
01536 }
01537
01538 NS_LOG_LOGIC ("TcpSocketImpl " << this << " retxing seq " << m_highestRxAck);
01539 if (m_retxEvent.IsExpired () )
01540 {
01541 Time rto = m_rtt->RetransmitTimeout ();
01542 NS_LOG_LOGIC (this<<" Schedule ReTxTimeout at time "
01543 << Simulator::Now ().GetSeconds () << " to expire at time "
01544 << (Simulator::Now () + rto).GetSeconds ());
01545 m_retxEvent = Simulator::Schedule (rto,&TcpSocketImpl::ReTxTimeout,this);
01546 }
01547 m_rtt->SentSeq (m_highestRxAck,p->GetSize ());
01548
01549 TcpHeader tcpHeader;
01550 tcpHeader.SetSequenceNumber (m_nextTxSequence);
01551 tcpHeader.SetAckNumber (m_nextRxSequence);
01552 tcpHeader.SetSourcePort (m_endPoint->GetLocalPort());
01553 tcpHeader.SetDestinationPort (m_remotePort);
01554 tcpHeader.SetFlags (flags);
01555 tcpHeader.SetWindowSize (AdvertisedWindowSize());
01556
01557 m_tcp->SendPacket (p, tcpHeader, m_endPoint->GetLocalAddress (),
01558 m_remoteAddress);
01559 }
01560
01561 void
01562 TcpSocketImpl::SetSndBufSize (uint32_t size)
01563 {
01564 m_sndBufSize = size;
01565 }
01566
01567 uint32_t
01568 TcpSocketImpl::GetSndBufSize (void) const
01569 {
01570 return m_sndBufSize;
01571 }
01572
01573 void
01574 TcpSocketImpl::SetRcvBufSize (uint32_t size)
01575 {
01576 m_rxBufMaxSize = size;
01577 }
01578
01579 uint32_t
01580 TcpSocketImpl::GetRcvBufSize (void) const
01581 {
01582 return m_rxBufMaxSize;
01583 }
01584
01585 void
01586 TcpSocketImpl::SetSegSize (uint32_t size)
01587 {
01588 m_segmentSize = size;
01589 }
01590
01591 uint32_t
01592 TcpSocketImpl::GetSegSize (void) const
01593 {
01594 return m_segmentSize;
01595 }
01596
01597 void
01598 TcpSocketImpl::SetSSThresh (uint32_t threshold)
01599 {
01600 m_ssThresh = threshold;
01601 }
01602
01603 uint32_t
01604 TcpSocketImpl::GetSSThresh (void) const
01605 {
01606 return m_ssThresh;
01607 }
01608
01609 void
01610 TcpSocketImpl::SetInitialCwnd (uint32_t cwnd)
01611 {
01612 m_initialCWnd = cwnd;
01613 }
01614
01615 uint32_t
01616 TcpSocketImpl::GetInitialCwnd (void) const
01617 {
01618 return m_initialCWnd;
01619 }
01620
01621 void
01622 TcpSocketImpl::SetConnTimeout (Time timeout)
01623 {
01624 m_cnTimeout = timeout;
01625 }
01626
01627 Time
01628 TcpSocketImpl::GetConnTimeout (void) const
01629 {
01630 return m_cnTimeout;
01631 }
01632
01633 void
01634 TcpSocketImpl::SetConnCount (uint32_t count)
01635 {
01636 m_cnCount = count;
01637 }
01638
01639 uint32_t
01640 TcpSocketImpl::GetConnCount (void) const
01641 {
01642 return m_cnCount;
01643 }
01644
01645 void
01646 TcpSocketImpl::SetDelAckTimeout (Time timeout)
01647 {
01648 m_delAckTimeout = timeout;
01649 }
01650
01651 Time
01652 TcpSocketImpl::GetDelAckTimeout (void) const
01653 {
01654 return m_delAckTimeout;
01655 }
01656
01657 void
01658 TcpSocketImpl::SetDelAckMaxCount (uint32_t count)
01659 {
01660 m_delAckMaxCount = count;
01661 }
01662
01663 uint32_t
01664 TcpSocketImpl::GetDelAckMaxCount (void) const
01665 {
01666 return m_delAckMaxCount;
01667 }
01668
01669 }
01670
01671 #ifdef RUN_SELF_TESTS
01672
01673 #include "ns3/test.h"
01674 #include "ns3/socket-factory.h"
01675 #include "ns3/tcp-socket-factory.h"
01676 #include "ns3/simulator.h"
01677 #include "ns3/simple-channel.h"
01678 #include "ns3/simple-net-device.h"
01679 #include "ns3/drop-tail-queue.h"
01680 #include "ns3/config.h"
01681 #include "internet-stack.h"
01682 #include <string>
01683
01684 namespace ns3 {
01685
01686 class TcpSocketImplTest: public Test
01687 {
01688 public:
01689 TcpSocketImplTest ();
01690 virtual bool RunTests (void);
01691 private:
01692
01693 void Test1 (void);
01694 void Test1_HandleConnectionCreated (Ptr<Socket>, const Address &);
01695 void Test1_HandleRecv (Ptr<Socket> sock);
01696
01697
01698 void Test2 (uint32_t payloadSize);
01699 void Test2_HandleConnectionCreated (Ptr<Socket>, const Address &);
01700 void Test2_HandleRecv (Ptr<Socket> sock);
01701 uint32_t test2_payloadSize;
01702
01703
01704 void Test3 (uint32_t payloadSize);
01705 void Test3_HandleConnectionCreated (Ptr<Socket>, const Address &);
01706 void Test3_HandleRecv (Ptr<Socket> sock);
01707 uint32_t test3_payloadSize;
01708
01709
01710 Ptr<Node> CreateInternetNode ();
01711 Ptr<SimpleNetDevice> AddSimpleNetDevice (Ptr<Node>,const char*,const char*);
01712 void SetupDefaultSim ();
01713
01714
01715 void Reset ();
01716
01717
01718
01719
01720 Ptr<Node> node0;
01721 Ptr<Node> node1;
01722 Ptr<SimpleNetDevice> dev0;
01723 Ptr<SimpleNetDevice> dev1;
01724 Ptr<SimpleChannel> channel;
01725 Ptr<Socket> listeningSock;
01726 Ptr<Socket> sock0;
01727 Ptr<Socket> sock1;
01728 uint32_t rxBytes0;
01729 uint32_t rxBytes1;
01730
01731 uint8_t* rxPayload;
01732
01733 bool result;
01734 };
01735
01736 TcpSocketImplTest::TcpSocketImplTest ()
01737 : Test ("TcpSocketImpl"),
01738 rxBytes0 (0),
01739 rxBytes1 (0),
01740 rxPayload (0),
01741 result (true)
01742 {
01743 }
01744
01745 bool
01746 TcpSocketImplTest::RunTests (void)
01747 {
01748 Test1();
01749 if (!result) return false;
01750 Test2(600);
01751 if (!result) return false;
01752 Test3(20000);
01753 return result;
01754 }
01755
01756
01757
01758
01759 void
01760 TcpSocketImplTest::Test1 ()
01761 {
01762 SetupDefaultSim ();
01763 listeningSock->SetAcceptCallback
01764 (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
01765 MakeCallback(&TcpSocketImplTest::Test1_HandleConnectionCreated,this));
01766 sock1->SetRecvCallback (MakeCallback(&TcpSocketImplTest::Test1_HandleRecv, this));
01767
01768 Simulator::Run ();
01769 Simulator::Destroy ();
01770
01771 result = result && (rxBytes1 == 13);
01772 result = result && (strcmp((const char*) rxPayload,"Hello World!") == 0);
01773
01774 Reset ();
01775 }
01776
01777 void
01778 TcpSocketImplTest::Test1_HandleConnectionCreated (Ptr<Socket> s, const Address & addr)
01779 {
01780 NS_ASSERT(s != listeningSock);
01781 NS_ASSERT(sock0 == 0);
01782 sock0 = s;
01783 const uint8_t* hello = (uint8_t*)"Hello World!";
01784 Ptr<Packet> p = Create<Packet> (hello, 13);
01785 sock0->Send(p);
01786
01787 sock0->SetRecvCallback (MakeCallback(&TcpSocketImplTest::Test1_HandleRecv, this));
01788 }
01789
01790 void
01791 TcpSocketImplTest::Test1_HandleRecv (Ptr<Socket> sock)
01792 {
01793 NS_ASSERT (sock == sock0 || sock == sock1);
01794 Ptr<Packet> p = sock->Recv();
01795 uint32_t sz = p->GetSize();
01796 if (sock == sock1)
01797 {
01798 rxBytes1 += sz;
01799 rxPayload = new uint8_t[sz];
01800 memcpy (rxPayload, p->PeekData(), sz);
01801 }
01802 else
01803 {
01804 NS_FATAL_ERROR ("Recv from unknown socket "<<sock);
01805 }
01806 }
01807
01808
01809
01810
01811 void
01812 TcpSocketImplTest::Test2 (uint32_t payloadSize)
01813 {
01814 test2_payloadSize = payloadSize;
01815 SetupDefaultSim ();
01816 listeningSock->SetAcceptCallback
01817 (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
01818 MakeCallback(&TcpSocketImplTest::Test2_HandleConnectionCreated,this));
01819 sock1->SetRecvCallback (MakeCallback(&TcpSocketImplTest::Test2_HandleRecv, this));
01820
01821 Simulator::Run ();
01822 Simulator::Destroy ();
01823
01824 result = result && (rxBytes1 == test2_payloadSize);
01825
01826 Reset ();
01827 }
01828
01829 void
01830 TcpSocketImplTest::Test2_HandleConnectionCreated (Ptr<Socket> s, const Address & addr)
01831 {
01832 NS_ASSERT(s != listeningSock);
01833 NS_ASSERT(sock0 == 0);
01834 sock0 = s;
01835 Ptr<Packet> p = Create<Packet> (test2_payloadSize);
01836 sock0->Send(p);
01837
01838 sock0->SetRecvCallback (MakeCallback(&TcpSocketImplTest::Test2_HandleRecv, this));
01839 }
01840
01841 void
01842 TcpSocketImplTest::Test2_HandleRecv (Ptr<Socket> sock)
01843 {
01844 NS_ASSERT (sock == sock0 || sock == sock1);
01845 Ptr<Packet> p = sock->Recv();
01846 uint32_t sz = p->GetSize();
01847 if (sock == sock1)
01848 {
01849 rxBytes1 += sz;
01850 }
01851 else
01852 {
01853 NS_FATAL_ERROR ("Not supposed to be back traffic in test 2..."<<sock);
01854 }
01855 }
01856
01857
01858
01859
01860 void
01861 TcpSocketImplTest::Test3 (uint32_t payloadSize)
01862 {
01863 Config::SetDefault ("ns3::TcpSocket::RcvBufSize", UintegerValue (10000));
01864 test3_payloadSize = payloadSize;
01865 SetupDefaultSim ();
01866 listeningSock->SetAcceptCallback
01867 (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
01868 MakeCallback(&TcpSocketImplTest::Test3_HandleConnectionCreated,this));
01869 sock1->SetRecvCallback (MakeCallback(&TcpSocketImplTest::Test3_HandleRecv, this));
01870
01871 Simulator::Run ();
01872 Simulator::Destroy ();
01873
01874 result = result && (rxBytes1 == test3_payloadSize);
01875
01876 Reset();
01877 }
01878 void
01879 TcpSocketImplTest::Test3_HandleConnectionCreated (Ptr<Socket> s, const Address &)
01880 {
01881 NS_ASSERT(s != listeningSock);
01882 NS_ASSERT(sock0 == 0);
01883 sock0 = s;
01884 Ptr<Packet> p = Create<Packet> (test3_payloadSize);
01885 sock0->Send(p);
01886 }
01887 void
01888 TcpSocketImplTest::Test3_HandleRecv (Ptr<Socket> sock)
01889 {
01890 NS_ASSERT_MSG (sock == sock1, "Not supposed to be back traffic in test 3... ");
01891 if(sock->GetRxAvailable() >= 10000 )
01892 {
01893 Ptr<Packet> p = sock->Recv();
01894 uint32_t sz = p->GetSize();
01895 rxBytes1 += sz;
01896 }
01897 }
01898
01899
01900
01901
01902 Ptr<Node>
01903 TcpSocketImplTest::CreateInternetNode ()
01904 {
01905 Ptr<Node> node = CreateObject<Node> ();
01906 AddInternetStack (node);
01907 return node;
01908 }
01909
01910 Ptr<SimpleNetDevice>
01911 TcpSocketImplTest::AddSimpleNetDevice (Ptr<Node> node, const char* ipaddr, const char* netmask)
01912 {
01913 Ptr<SimpleNetDevice> dev = CreateObject<SimpleNetDevice> ();
01914 dev->SetAddress (Mac48Address::Allocate ());
01915 node->AddDevice (dev);
01916 Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
01917 uint32_t ndid = ipv4->AddInterface (dev);
01918 ipv4->SetAddress (ndid, Ipv4Address (ipaddr));
01919 ipv4->SetNetworkMask (ndid, Ipv4Mask (netmask));
01920 ipv4->SetUp (ndid);
01921 return dev;
01922 }
01923
01924 void
01925 TcpSocketImplTest::SetupDefaultSim ()
01926 {
01927 const char* netmask = "255.255.255.0";
01928 const char* ipaddr0 = "192.168.1.1";
01929 const char* ipaddr1 = "192.168.1.2";
01930 node0 = CreateInternetNode ();
01931 node1 = CreateInternetNode ();
01932 dev0 = AddSimpleNetDevice (node0, ipaddr0, netmask);
01933 dev1 = AddSimpleNetDevice (node1, ipaddr1, netmask);
01934
01935 channel = CreateObject<SimpleChannel> ();
01936 dev0->SetChannel (channel);
01937 dev1->SetChannel (channel);
01938
01939 Ptr<SocketFactory> sockFactory0 = node0->GetObject<TcpSocketFactory> ();
01940 Ptr<SocketFactory> sockFactory1 = node1->GetObject<TcpSocketFactory> ();
01941
01942 listeningSock = sockFactory0->CreateSocket();
01943 sock1 = sockFactory1->CreateSocket();
01944
01945 uint16_t port = 50000;
01946 InetSocketAddress serverlocaladdr (Ipv4Address::GetAny(), port);
01947 InetSocketAddress serverremoteaddr (Ipv4Address(ipaddr0), port);
01948
01949 listeningSock->Bind(serverlocaladdr);
01950 listeningSock->Listen ();
01951
01952 sock1->Connect(serverremoteaddr);
01953 }
01954
01955 void
01956 TcpSocketImplTest::Reset ()
01957 {
01958 node0 = 0;
01959 node1 = 0;
01960 dev0 = 0;
01961 dev1 = 0;
01962 channel = 0;
01963 listeningSock = 0;
01964 sock0 = 0;
01965 sock1 = 0;
01966 rxBytes0 = 0;
01967 rxBytes1 = 0;
01968 delete[] rxPayload;
01969 rxPayload = 0;
01970 }
01971
01972 static TcpSocketImplTest gTcpSocketImplTest;
01973
01974 }
01975
01976 #endif