开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
imep.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：29k
源码类别：

通讯编程

开发平台：

Visual C++

imep.cc：源码内容
  1. /* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  *      This product includes software developed by the Computer Systems
  17.  *      Engineering Group at Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  *
  34.  * Ported from CMU/Monarch's code 
  35.  *
  36.  * $Header: /cvsroot/nsnam/ns-2/imep/imep.cc,v 1.12 2006/02/21 15:20:18 mahrenho Exp $
  37.  */
  39. #include <packet.h>
  40. #include <ip.h>
  41. #include <random.h>
  43. #include <cmu-trace.h>
  44. #include <imep/imep.h>
  46. #define CURRENT_TIME Scheduler::instance().clock()
  48. static const int verbose = 0;
  49. static const int imep_use_mac_callback = 1;
  51. // ======================================================================
  52. //   TCL Hooks
  53. // ======================================================================
  55. int hdr_imep::offset_;
  56. static class IMEPHeaderClass : public PacketHeaderClass {
  57. public:
  58.         IMEPHeaderClass() : PacketHeaderClass("PacketHeader/IMEP",
  59.       IMEP_HDR_LEN) { 
  60. bind_offset(&hdr_imep::offset_);
  61. } 
  62. } class_imep_hdr;
  64. static class agentIMEPclass : public TclClass {
  65. public:
  66. agentIMEPclass() : TclClass("Agent/IMEP") {}
  67. TclObject* create(int argc, const char*const* argv) {
  68. assert(argc == 5);
  69. return (new imepAgent((nsaddr_t) atoi(argv[4])));
  70. }
  71. } class_imepAgent;
  74. // ======================================================================
  75. // ======================================================================
  77. // MAC layer callback
  78. static void
  79. imep_failed_callback(Packet *p, void *arg)
  80. {
  81. if(imep_use_mac_callback)
  82. ((imepAgent*) arg)->imepPacketUndeliverable(p);
  83. else {
  84. Packet::free(p);
  85. // XXX: Should probably call a "drop" agent here
  86. }
  87. }
  89. imepAgent::imepAgent(nsaddr_t index) :
  90. Agent(PT_TORA),
  91. beaconTimer(this, BEACON_TIMER),
  92. controlTimer(this, CONTROL_TIMER),
  93. rexmitTimer(this, REXMIT_TIMER),
  94. incomingTimer(this, INCOMING_TIMER),
  95. ipaddr(index),
  96. incomingQ(this, index)
  97. {
  98. controlSequence = 0;
  99. recvtarget_ = sendtarget_ = 0;
  100. logtarget_ = 0;
  101. rtagent_ = 0;
  102. LIST_INIT(&imepLinkHead);
  103. bzero(&stats, sizeof(stats));
  104. }
  106. int
  107. imepAgent::command(int argc, const char*const* argv)
  108. {
  109. if(argc == 2) {
  110. if(strcmp(argv[1], "start") == 0) {
  111. beaconTimer.start(BEACON_PERIOD);
  112. return TCL_OK;
  113. } 
  114. else if(strcmp(argv[1], "reset") == 0) {
  115.         Terminate();
  116. return TCL_OK;
  117. }
  118. } else if (argc == 3) {
  119. if (strcmp(argv[1], "recvtarget") == 0) {
  120. recvtarget_ = (NsObject*) TclObject::lookup(argv[2]);
  121.                         assert(recvtarget_);
  122. return (TCL_OK);
  123. }
  124. else if (strcmp(argv[1], "sendtarget") == 0) {
  125. sendtarget_ = (NsObject*) TclObject::lookup(argv[2]);
  126.                         assert(sendtarget_);
  127. return (TCL_OK);
  128. }
  129. else if (strcmp(argv[1], "rtagent") == 0) {
  130. rtagent_ = (rtAgent*) TclObject::lookup(argv[2]);
  131. assert(rtagent_);
  132. return (TCL_OK);
  133. }
  134. else if(strcmp(argv[1], "log-target") == 0) {
  135. logtarget_ = (Trace*) TclObject::lookup(argv[2]);
  136. assert(logtarget_);
  137. return (TCL_OK);
  138. }
  139. }
  140. return Agent::command(argc, argv);
  141. }
  144. imepLink*
  145. imepAgent::findLink(nsaddr_t index)
  146. {
  147. imepLink *l;
  149. for(l = imepLinkHead.lh_first; l; l = l->link.le_next) {
  150. if(l->index() == index)
  151. return l;
  152. }
  153. return 0;
  154. }
  156. Packet*
  157. imepAgent::findObjectSequence(u_int8_t seqno)
  158. {
  159.         Packet *p;
  160. ReXmitQIter iter = rexmitq.iter();
  161. struct imep_object_block *ob;
  163. while ((p = iter.next())) {
  164. ob = findObjectBlock(p);
  166. if(ob == 0) continue;
  167. // no OBJECT block
  169. if(ob->ob_sequence != seqno) continue;
  170. // wrong SEQUENCE number
  172. if(ob->ob_num_responses <=0) {
  173. fprintf(stderr,
  174. "imepAgent::findObjectSequence: "
  175. "Object Block without response listn");
  176. abort();
  177. }
  179. return p;
  180. }
  182. /* abort();
  183. this isn't an abort condition.  consider an ack arriving 
  184. for a pkt after it's timed out from the rexmit q -dam */
  186. return NULL;
  187. }
  190. void
  191. imepAgent::removeObjectResponse(Packet *p, nsaddr_t index)
  192. {
  193. struct imep_object_block *ob = findObjectBlock(p);
  194. struct imep_response *r = findResponseList(p);
  195. struct imep_response *r0;
  196. struct hdr_cmn *ch = HDR_CMN(p);
  197. int i;
  199. assert(ob && r);
  201. for(i = 0, r0 = r; i < ob->ob_num_responses; i++, r0++) {
  202. if(INT32_T(r0->resp_ipaddr) == index)
  203. break;
  204. }
  206. if(INT32_T(r0->resp_ipaddr) != index) {
  207.   if (verbose) 
  208.     trace("T %.9f _%d_ dup ack(?) from %d", CURRENT_TIME, ipaddr, index);
  209.   return;
  210. }
  212. if(ob->ob_num_responses == 1) {
  213.         if (verbose) 
  214.            trace("T %.9f _%d_ remove from reXq pkt %d", 
  215.          CURRENT_TIME, ipaddr, ch->uid());
  216.         rexmitq.remove(p);
  217.         Packet::free(p);
  218. stats.num_rexmitable_fully_acked++;
  219. } else {
  220. // find the last "response"
  221.            r += (ob->ob_num_responses - 1);
  223. if(r != r0) {
  224. INT32_T(r0->resp_ipaddr) = INT32_T(r->resp_ipaddr);
  225. }
  227. ob->ob_num_responses -= 1;
  229.         if (verbose) 
  230.            trace("T %.9f _%d_ remove %d from resp list %d (%d left) RL %s", 
  231.          CURRENT_TIME, ipaddr, index, ch->uid(), ob->ob_num_responses, 
  232.  dumpResponseList(p));
  234. struct hdr_imep *im = HDR_IMEP(p);
  235. ch->size() -= sizeof(struct imep_response);
  236. U_INT16_T(im->imep_length) -= sizeof(struct imep_response);
  237. }
  238. }
  241. void 
  242. imepAgent::purgeReXmitQ(nsaddr_t index)
  243.   // remove index from any response lists in the rexmit q
  244. {
  245.   Packet *p;
  246.   ReXmitQIter iter = rexmitq.iter();
  247.   struct imep_object_block *ob;
  248.   struct imep_response *r,*r0;
  249.   struct hdr_cmn *ch;
  250.   int i;
  252.   if (verbose)
  253.     trace("T %.9f _%d_ purge %d from reXmit Q", 
  254.   CURRENT_TIME, ipaddr, index);
  256.   while ((p = iter.next())) {
  257.     ob = findObjectBlock(p);
  258.     if(ob == 0) assert(0); // should always be an object block
  260.     r = findResponseList(p);
  261.     ch = HDR_CMN(p);
  263.     assert(ob && r);
  265.     for(i = 0, r0 = r; i < ob->ob_num_responses; i++, r0++) {
  266.       if(INT32_T(r0->resp_ipaddr) == index)
  267. break;
  268.     }
  270.     if(INT32_T(r0->resp_ipaddr) != index) {
  271.       continue; // index not in this response list
  272.     }
  274.     if(ob->ob_num_responses == 1) {
  275.       if (verbose) 
  276. trace("T %.9f _%d_ remove from reXq pkt %d",
  277.       CURRENT_TIME, ipaddr, ch->uid());
  278.       rexmitq.remove(p);
  279.       drop(p, DROP_RTR_QTIMEOUT);
  280.       stats.num_rexmitable_fully_acked++;
  281.     } else {
  282.       // find the last "response"
  283.       r += (ob->ob_num_responses - 1);
  285.       if(r != r0) {
  286. INT32_T(r0->resp_ipaddr) = INT32_T(r->resp_ipaddr);
  287.       }
  289.       ob->ob_num_responses -= 1;
  291.       if (verbose) 
  292. trace("T %.9f _%d_ purge %d from resp list %d (%d left) RL %s", 
  293.       CURRENT_TIME, ipaddr, index, ch->uid(), ob->ob_num_responses, 
  294.       dumpResponseList(p));
  296.       struct hdr_imep *im = HDR_IMEP(p);
  297.       ch->size() -= sizeof(struct imep_response);
  298.       U_INT16_T(im->imep_length) -= sizeof(struct imep_response);
  299.     }
  300.   }
  301. }
  304. // ======================================================================
  305. // ======================================================================
  306. // Timer Handling Functions
  308. void
  309. imepAgent::handlerTimer(imepTimerType t)
  310. {
  311. switch(t) {
  312. case BEACON_TIMER:
  313. handlerBeaconTimer();
  314. break;
  315. case CONTROL_TIMER:
  316. handlerControlTimer();
  317. break;
  318. case REXMIT_TIMER:
  319.         handlerReXmitTimer();
  320. break;
  321. case INCOMING_TIMER:
  322. handlerIncomingTimer();
  323. break;
  324. default:
  325. abort();
  326. }
  327. }
  329. void
  330. imepAgent::handlerBeaconTimer(void)
  331. {
  332.   imepLink *l;
  334.   // garbage collect old links
  335.   purgeLink();
  337.   if (verbose) log_neighbor_list();
  339.   /* aside from the debugging asserts, handleControlTimer will generate a
  340.    ``beacon'' packet if there are no objects pending, so we could
  341.    just call it.  Since we have sendBeacon() laying around, though, 
  342.    I'll call it and leave the debugging asserts in handleControlTimer()
  344.    The packet generated by handlerControlTimer is a beacon equivelent, 
  345.    so we don't need to generate a beacon. */
  347.   if (controlTimer.busy() || helloQueue.length() > 0)
  348.     { // a control timer is pending or there's left over Hello's in the queue, 
  349.       // but we're about to service all pending acks, hellos, and objects now, 
  350.       // so cancel the timer
  351.       if (controlTimer.busy()) controlTimer.cancel();
  352.       handlerControlTimer();
  353.     }
  354.   else 
  355.     { // all the Hellos we had to send out during the last BEACON_PERIOD
  356.       // went out.  Assuming there were some, they were beacon equivelent,
  357.       // and we don't need to send a beacon now.  If there were none, beacon
  358.       if (NULL == imepLinkHead.lh_first) sendBeacon();
  359.       // this is a touch conservative, since if there were hellos that went out
  360.       // but their links were down'd by purgeLink, we'll still beacon.
  361.       // But, if we *have*no* adjacencies, we should do something to get some
  362.     }
  364.   /* Send a hello to all our IN adjacencies (everyone we've heard a
  365.      packet from). This loads up the helloQueue with all the hellos that
  366.      that need to go out sometime in the next BEACON_PERIOD before the
  367.      beaconTimer goes off, but doesn't start the controlTimer.  If a
  368.      control packet is sent for some other reason, the hellos will ride out
  369.      for free, otherwise they'll go out when the beacon timer goes off.
  370.      */
  371.   int busy_before_hello_load = controlTimer.busy();
  372.   for(l = imepLinkHead.lh_first; l; l = l->link.le_next) 
  373.     {
  374.       if (l->status() & LINK_IN) sendHello(l->index());
  375.     }
  376.   if (!busy_before_hello_load && controlTimer.busy()) controlTimer.cancel();
  378.   // restart the beacon timer
  379.   beaconTimer.start(BEACON_PERIOD);
  380. }
  383. // transmit all queued ACKs, HELLOs, and OBJECTs.
  384. void
  385. imepAgent::handlerControlTimer(void)
  386. {
  387. Packet *p;
  389. int num_acks = ackQueue.length();
  390. int num_hellos = helloQueue.length();
  391. int num_objects = objectQueue.length();
  393. MAKE_PACKET:
  394. assert(num_acks + num_hellos + num_objects > 0);
  396. // now have to aggregate multiple control packets
  398. p = Packet::alloc();
  400. struct hdr_cmn *ch = HDR_CMN(p);
  401. struct hdr_ip *ih = HDR_IP(p);
  402. struct hdr_imep *im = HDR_IMEP(p);
  404. ch->uid() = uidcnt_++;
  405. ch->ptype() = PT_IMEP;
  406. ch->size() = BEACON_HDR_LEN;
  407. ch->iface() = -2;
  408. ch->error() = 0;
  409. ch->addr_type() = NS_AF_NONE;
  410.         ch->prev_hop_ = ipaddr;
  412. ih->saddr() = ipaddr;
  413. ih->daddr() = IP_BROADCAST;
  414. ih->sport() = RT_PORT;
  415. ih->dport() = RT_PORT;
  416. ih->ttl_ = 1;
  418. im->imep_version = IMEP_VERSION;
  419. im->imep_block_flags = 0x00;
  420. U_INT16_T(im->imep_length) = sizeof(struct hdr_imep);
  422. aggregateAckBlock(p);
  423. aggregateHelloBlock(p);
  424. aggregateObjectBlock(p);
  426. imep_output(p);
  428. num_acks = ackQueue.length();
  429. num_hellos = helloQueue.length();
  430. num_objects = objectQueue.length();
  431. if (num_acks + num_hellos + num_objects > 0)
  432.   { // not done yet...
  433.     if (verbose) 
  434.       trace("T %.9f _%d_ imep pkt overflow %d %d %d leftover",
  435.     CURRENT_TIME, ipaddr, num_acks, num_hellos, num_objects);
  436.     goto MAKE_PACKET;
  437.   }
  439. // don't need to restart the controlTimer because the arrival of
  440. // the next packet from an ULP will start it.
  441. }
  443. void
  444. imepAgent::handlerReXmitTimer() 
  445. {
  446.   Packet *p;
  447.   Time rexat;
  448.   int num_xmits_left;
  450.   rexmitq.peekHead(&rexat, &p, &num_xmits_left);
  452.   if (NULL == p) return;  //  no more pkts on queue
  453.   struct hdr_cmn *ch = HDR_CMN(p);
  455.   if (0 == num_xmits_left)
  456.     {
  457.       if (verbose) 
  458. {
  459.   trace("T %.9f _%d_ rexmit timed out %d RL:%s",
  460. CURRENT_TIME, ipaddr, ch->uid(), dumpResponseList(p));
  461. }
  463.         struct imep_object_block *ob = findObjectBlock(p);
  464. struct imep_response *r = findResponseList(p);
  465. int i;
  467. for(i = 0; i < ob->ob_num_responses; i++, r++) 
  468.   {
  469.     if (verbose) trace("T %.9f _%d_ punting neighbor %d",
  470.        CURRENT_TIME, ipaddr, INT32_T(r->resp_ipaddr));
  471.     imepSetLinkDownStatus(INT32_T(r->resp_ipaddr));
  472.   }
  474.       stats.num_rexmitable_retired++;
  475.       stats.sum_rexmitable_retired_response_sz += ob->ob_num_responses;
  478.       // don't need to explicitly remove p from q and drop it, since
  479.       // by downing all the links on it's response list, it'll have bee
  480.       // dropped anyway
  481.       // rexmitq.removeHead();
  482.       // drop(p, DROP_RTR_QTIMEOUT);
  483.     }
  484.   else if (rexat <= CURRENT_TIME) 
  485.     {
  486.       if (verbose) 
  487. trace("T %.9f _%d_ rexmit %d as %d",
  488.       CURRENT_TIME, ipaddr, ch->uid(), uidcnt_);
  489.       ch->uid() = uidcnt_++;
  490.       imep_output(p->copy());
  492.       num_xmits_left--;
  493.       rexmitq.removeHead(); // take it off the queue and reinsert it
  494.       rexmitq.insert(CURRENT_TIME + RETRANS_PERIOD, p, num_xmits_left);
  496.       stats.num_rexmits++;
  497.     }  
  498.   
  499.   // reschedule the timer
  500.   rexmitq.peekHead(&rexat, &p, &num_xmits_left);
  501.   if (NULL == p) return;  //  no more pkts on queue
  502.   if (verbose) trace("T %.9f _%d_ rexmit trigger again for %d at %.9f (in %.9f)",
  503.      CURRENT_TIME, ipaddr, ch->uid(), rexat, rexat - CURRENT_TIME );
  504.   rexmitTimer.start(rexat - CURRENT_TIME);
  505. }
  508. void
  509. imepAgent::handlerIncomingTimer()
  510. {
  511. Packet *p;
  512. u_int32_t s;
  513. double expire;
  514. int index;
  516. if (verbose) trace("T %.9f _%d_ inorder - timer expired",
  517.       CURRENT_TIME, ipaddr);
  519. incomingQ.dumpAll();
  521. while((p = incomingQ.getNextPacket(s))) {
  522. stats.num_holes_retired++;
  524. index = HDR_IP(p)->saddr();
  525. imepLink *l = findLink(index);
  526. assert(l);  // if there's no link entry, then the incoming
  527. // q should have been cleared, when the link entry was destroyed
  529. if(verbose) 
  530.   trace("T %.9f _%d_ inorder - src %d hole retired seq %d -> %d",
  531. CURRENT_TIME, ipaddr, index, l->lastSeq(), s);
  533. /* tell ULP that we've effectively broken our link to 
  534.    neighbor by retiring the hole and accepting the deletion.
  535.    since we don't do this till at least MAX_REXMIT_TIME after
  536.    receiving the out of seq packet, we're sure the packet's sender
  537.    must have timed us out when we didn't ack their packet.
  538.    can't call imepLinkDown b/c it'll purge the reseq q */
  539. rtagent_->rtNotifyLinkDN(index);
  540. stats.delete_neighbor3++;
  541. rtagent_->rtNotifyLinkUP(index);
  542. stats.new_neighbor++;
  544. if (verbose)
  545.   trace("T %.9f _%d_ inorder - src %d seq %d (timer delivery)",
  546. CURRENT_TIME, ipaddr, index, s);
  548. l->lastSeq() = s;  // advance sequence number for this neighbor
  550. stats.num_recvd_from_queue++;
  551. imep_object_process(p);
  552. Packet::free(p);
  554. // now deliver as many in sequence packets to ULP as possible
  555. Packet *p0;
  556. while((p0 = incomingQ.getPacket(index, l->lastSeq() + 1)))
  557.   {
  558.     if (verbose)
  559.       trace("T %.9f _%d_ inorder - src %d seq %d (chain" 
  560.     " timer delivery)", CURRENT_TIME, ipaddr, 
  561.     HDR_IP(p0)->saddr(), l->lastSeq() + 1);
  562.     l->lastSeq() += 1;
  563.     stats.num_recvd_from_queue++;
  564.     imep_object_process(p0);
  565.     Packet::free(p0);
  566.   }
  567. }
  569. if((expire = incomingQ.getNextExpire()) != 0.0) {
  570. assert(expire > CURRENT_TIME);
  571. if (verbose)
  572.   trace("T %.9f _%d_ inorder - timer started (delay %.9f)",
  573. CURRENT_TIME, ipaddr, expire - CURRENT_TIME);
  574.         incomingTimer.start(expire - CURRENT_TIME);
  575. }
  576. }
  579. //////////////////////////////////////////////////////////////////////
  581. void
  582. imepAgent::scheduleReXmit(Packet *p)
  583. {
  584.   rexmitq.insert(CURRENT_TIME + RETRANS_PERIOD, p, MAX_REXMITS);
  585.   
  586.   // start the timer
  587.   if (!rexmitTimer.busy()) rexmitTimer.start(RETRANS_PERIOD);    
  588. }
  590. void
  591. imepAgent::scheduleIncoming(Packet *p, u_int32_t s)
  592. {
  593. struct hdr_ip *ip = HDR_IP(p);
  595. incomingQ.addEntry(ip->saddr(), CURRENT_TIME + MAX_RETRANS_TIME, s, p);
  596.   
  597. // start the timer
  598. if (!incomingTimer.busy()) {
  599. if (verbose) 
  600.   trace("T %.9f _%d_ inorder - timer started",
  601. CURRENT_TIME, ipaddr);
  602. incomingTimer.start(MAX_RETRANS_TIME);
  603. }
  604. }
  607. // ======================================================================
  608. // Packet Processing Functions
  610. void
  611. imepAgent::recv(Packet *p, Handler *)
  612. {
  613. //struct hdr_ip *ih = HDR_IP(p);
  614. struct hdr_cmn *ch = HDR_CMN(p);
  616. assert(initialized());
  618. if(ch->prev_hop_ == ipaddr) {
  619.   // I hate all uses of prev_hop, but the only other way to
  620.   // do this test is by checking for a nonNULL handler (like 
  621.   // mac-801_11.cc does), which would
  622.   // require changing tora to send out pkts with a non 0 hndler
  623.   // -dam
  624. recv_outgoing(p);
  625. } else {
  626.         recv_incoming(p);
  627. }
  628. }
  630. void
  631. imepAgent::recv_outgoing(Packet *p)
  632. {
  633. struct hdr_cmn *ch = HDR_CMN(p);
  634. struct hdr_ip *ip = HDR_IP(p);
  636. if(DATA_PACKET(ch->ptype())) {
  637. imep_output(p);
  638. return;
  639. }
  641. if(ip->daddr() != (nsaddr_t) IP_BROADCAST) {
  642. fprintf(stderr, "IP dst is unicast - not encapsulatingn");
  643. imep_output(p);
  644. return;
  645. }
  647. assert(ch->ptype() == PT_TORA);
  648. // XXX: for debugging purposes - IMEP supports other object types
  650. objectQueue.enque(p);
  651. // this queue is a queue of "packets" passed down from the 
  652. // upper layer routing protocols that IMEP will buffer and try
  653. // to aggregate before transmitting.  Although these are valid
  654. // packets, they must not be transmitted before encaspulating
  655. // them in an IMEP packet to ensure reliability.
  657. double send_delay = MIN_TRANSMIT_WAIT_TIME_HIGHP
  658.   + ((MAX_TRANSMIT_WAIT_TIME_HIGHP - MIN_TRANSMIT_WAIT_TIME_HIGHP)
  659.      * Random::uniform());
  660. if (controlTimer.busy() == 0) 
  661.   {
  662.     controlTimer.start(send_delay);
  663.   } 
  664. else if (controlTimer.timeLeft() > send_delay) 
  665.   {
  666.     controlTimer.cancel();
  667.     controlTimer.start(send_delay);
  668.   }
  669. }
  671. void
  672. imepAgent::recv_incoming(Packet *p)
  673. {
  674. struct hdr_cmn *ch = HDR_CMN(p);
  675. struct hdr_ip *ih = HDR_IP(p);
  676. struct hdr_imep *im = HDR_IMEP(p);
  678. if(DATA_PACKET(ch->ptype())) {
  679. imep_input(p);
  680. return;
  681. }
  683. // if it's a data packet, the ip->src could be from far away,
  684. // so we can't use it for link indications.  If we RARPd the 
  685. // MAC source addr, we could use that...
  687. imepSetLinkInStatus(ih->saddr());
  688. // XXX: this could be done at the MAC layer.  In fact, I will 
  689. // augment the IEEE 802.11 layer so that the receipt of an
  690. // ACK confirms bidirectional status. -josh
  691. // hasn't actually be done. seems unlikely to be of help, and is
  692. // fairly hard to do. -dam 8/19/98
  693.         assert(ch->ptype() == PT_IMEP);
  694. assert(im->imep_version == IMEP_VERSION);
  696. if(im->imep_block_flags == 0) {
  697. imep_beacon_input(p);
  698. Packet::free(p);
  699. return;
  700. }
  702. if(im->imep_block_flags & BLOCK_FLAG_ACK)
  703. imep_ack_input(p);
  705. if(im->imep_block_flags & BLOCK_FLAG_HELLO)
  706. imep_hello_input(p);
  708. if(im->imep_block_flags & BLOCK_FLAG_OBJECT) {
  709. imep_object_input(p);
  710. // each upper layer object will be decapsulated and
  711. // placed into its own packet before being passed
  712. // to the upper layer.  This provides total transparency
  713. // to the upper layer.
  714. }
  716. Packet::free(p);
  717. }
  719. void
  720. imepAgent::imep_beacon_input(Packet *p)
  721. {
  722. struct hdr_ip *ip = HDR_IP(p);
  724. sendHello(ip->saddr());
  725. }
  728. // If there is an ACK for us we need to (1) removed the sender
  729. // of the ACK from the "ack list", and we need to update the
  730. // status of this neighbor to "BIDIRECTIONAL".
  731. void
  732. imepAgent::imep_ack_input(Packet *p)
  733. {
  734. struct hdr_ip *ih = HDR_IP(p);
  735. struct imep_ack_block *ab = findAckBlock(p);
  736. struct imep_ack *ack;
  738. assert(ab);
  739. ack = (struct imep_ack*) (ab + 1);
  741. // According to the IMEP specs, the ACK block (if it exists)
  742. // immediately follows the 3-byte IMEP header.
  744. for(int i = 0; i < ab->ab_num_acks; i++, ack++) {
  745. if(INT32_T(ack->ack_ipaddr) == ipaddr) {
  747. Packet *p0 = findObjectSequence(ack->ack_seqno);
  748. if (NULL == p0)
  749.   {
  750.     if(verbose) 
  751.       trace("T %.9f _%d_ %d acks seq %d : no obj"
  752.     " block", CURRENT_TIME, ipaddr, 
  753.     ih->saddr(), ack->ack_seqno);
  754.     stats.num_unexpected_acks++;
  755.     continue;
  756.   }
  758. removeObjectResponse(p0, ih->saddr());
  760. imepSetLinkBiStatus(ih->saddr());
  761. }
  762. }
  763. }
  765. void
  766. imepAgent::imep_hello_input(Packet *p)
  767. {
  768. struct hdr_ip *ip = HDR_IP(p);
  769. struct imep_hello_block *hb = findHelloBlock(p);
  770. struct imep_hello *hello;
  772. assert(hb);
  773. hello = (struct imep_hello*) (hb + 1);
  775. for(int i = 0; i < hb->hb_num_hellos; i++, hello++) {
  776. if(INT32_T(hello->hello_ipaddr) == ipaddr) {
  778. imepSetLinkBiStatus(ip->saddr());
  780. break;
  781. }
  782. }
  783. }
  785. void
  786. imepAgent::imep_object_input(Packet *p)
  787. {
  788. struct imep_object_block *ob;
  790. // First, send an ack for the object
  791. imep_ack_object(p);
  793. // now see what to do with the object
  794. ob = findObjectBlock(p);
  795. assert(ob);
  797. struct hdr_ip *iph = HDR_IP(p);
  798. imepLink *l = findLink(iph->saddr());
  799. assert(l);  // if we have an object, a link entry should already exist
  801. if (!l->lastSeqValid()) 
  802.   { // first object we've heard from this node
  803.     l->lastSeqValid() = 1;
  804.     l->lastSeq() = ob->ob_sequence - 1;
  805.     if (verbose)
  806.       trace("T %.9f _d_ first object from neighbor %d seq %d",
  807.     CURRENT_TIME, ipaddr, iph->saddr(), ob->ob_sequence);
  808.   }
  810. // This calc requires sequence number SEQ_GT() semantics
  811. // Life will be very bad if this calc isn't actually done in 
  812. // a register the size of the sequence number space
  813. int8_t reg = (int8_t) ob->ob_sequence - (int8_t) l->lastSeq();
  815. if(reg <= 0)
  816.   { // already passed this pkt up to ULP or declared it a permenant
  817.     // hole
  818.     if (verbose)
  819.       trace("T %.9f _%d_ from %d ignored seq %d (already heard)",
  820.     CURRENT_TIME, ipaddr, iph->saddr(), ob->ob_sequence);
  821.     stats.num_out_of_window_objs++;
  822.     return;
  823.   }
  825. if (verbose && reg > 1)
  826.   { // found a hole in the sequence number space...
  827.     trace("T %.9f _%d_ inorder - src %d seq %d out of order (%d expected)",
  828.   CURRENT_TIME, ipaddr, iph->saddr(),
  829.   ob->ob_sequence, l->lastSeq()+1);
  830.   }
  832. if (1 == reg)
  833.   { // ``fast path''
  834.     // got the expected next seq num
  836.     if (verbose)
  837.       trace("T %.9f _%d_ inorder - fastpath src %d seq %d (delivering)",
  838.     CURRENT_TIME, ipaddr, HDR_IP(p)->saddr(), ob->ob_sequence);
  839.     stats.num_in_order_objs++;
  841.     imep_object_process(p);
  842.     assert((u_int8_t)(l->lastSeq() + 1) == ob->ob_sequence);
  843.     l->lastSeq() = ob->ob_sequence;
  844.   }
  845. else
  846.   {
  847.     // put this packet on the resequencing queue
  848.     scheduleIncoming(p->copy(), ob->ob_sequence);
  849.     stats.num_out_of_order_objs++;
  850.   }
  852. // now deliver as many in-sequence packets to ULP as possible
  853. Packet *p0;
  854. while((p0 = incomingQ.getPacket(iph->saddr(), l->lastSeq() + 1)))
  855.   {
  856.     stats.num_recvd_from_queue++;
  857.     if (verbose)
  858.       trace("T %.9f _%d_ inorder - src %d seq %d (delivering)",
  859.     CURRENT_TIME, ipaddr, HDR_IP(p0)->saddr(), l->lastSeq() + 1);
  860.     l->lastSeq() += 1;
  861.     imep_object_process(p0);
  862.     Packet::free(p0);
  863.   }
  864. }
  866. void
  867. imepAgent::imep_object_process(Packet *p)
  868.   // hand the conents of any object in the pkt to the respective ULP
  869. {
  870.   struct imep_object_block *ob;
  871.   struct imep_object *object;
  872.   int i;
  874.   stats.num_object_pkts_recvd++;
  876.   ob = findObjectBlock(p);
  877.   assert(ob);
  878.   assert(ob->ob_protocol_type == PROTO_TORA); // XXX: more general later
  880.   object = (struct imep_object*) (ob + 1);
  882.   for(i = 0; i < ob->ob_num_objects; i++)
  883.     {
  884.       Packet *p0 = p->copy();
  886.       assert(object->o_length > 0); // sanity check
  888.       toraCreateHeader(p0,
  889.        ((char*) object) + IMEP_OBJECT_SIZE,
  890.        object->o_length);
  892.       imep_input(p0);
  894.       object = (struct imep_object*) ((char*) object + 
  895.              IMEP_OBJECT_SIZE + object->o_length);
  896.     }
  897. }
  900. void
  901. imepAgent::imep_ack_object(Packet *p)
  902.   // send an ack for the object in p, if any
  903. {
  904.   struct hdr_ip *iph = HDR_IP(p);
  905.   struct imep_object_block *ob;
  906.   struct imep_object *object;
  907.   int i;
  909.   ob = findObjectBlock(p);
  910.   if (!ob) return;
  912.   if (0 == ob->ob_num_responses) 
  913.     return;
  915.   if (31 == ob->ob_num_responses) 
  916.     { // a ``broadcast'' response list to which everyone replies
  917.       sendAck(iph->saddr(), ob->ob_sequence);
  918.       return;
  919.     }
  921.   object = (struct imep_object*) (ob + 1);
  923.   // walk the objects to find the response list
  924.   for(i = 0; i < ob->ob_num_objects; i++)
  925.     {
  926.       object = (struct imep_object*) ((char*) object + 
  927.       IMEP_OBJECT_SIZE +object->o_length);
  928.     }
  930.   struct imep_response *r = (struct imep_response*) object;
  931.   for (i = 0; i < ob->ob_num_responses; i++)
  932.     {
  933.       if (INT32_T(r->resp_ipaddr) == ipaddr)
  934. {
  935.   sendAck(iph->saddr(), ob->ob_sequence);
  936.   break;
  937. }
  938.       r = r + 1;
  939.     }
  940. }
  942. // ======================================================================
  943. // ======================================================================
  944. // Routines by which packets leave the IMEP object
  946. void
  947. imepAgent::imep_input(Packet *p)
  948. {
  949. recvtarget_->recv(p, (Handler*) 0);
  950. }
  952. void
  953. imepAgent::imep_output(Packet *p)
  954. {
  955. struct hdr_cmn *ch = HDR_CMN(p);
  957. if(imep_use_mac_callback) {
  958. ch->xmit_failure_ = imep_failed_callback;
  959. ch->xmit_failure_data_ = (void*) this;
  960. } else {
  961. ch->xmit_failure_ = 0;
  962. ch->xmit_failure_data_ = 0;
  963. }
  964. ch->xmit_reason_ = 0;
  966.   sendtarget_->recv(p, (Handler*) 0);
  967. }
  969. // ======================================================================
  970. // ======================================================================
  971. // Debugging routines
  973. void
  974. imepAgent::imep_dump_header(Packet *p)
  975. {
  976. struct hdr_imep *im = HDR_IMEP(p);
  978. fprintf(stderr,
  979. "imep_version: 0x%xn", im->imep_version);
  980. fprintf(stderr,
  981. "imep_block_flags: 0x%xn", im->imep_block_flags);
  982. fprintf(stderr,
  983. "imep_length: 0x%04xn", U_INT16_T(im->imep_length));
  985. Packet::dump_header(p, hdr_imep::offset_, 64);
  986. }
  988. void
  989. imepAgent::log_neighbor_list()
  990. {
  991. imepLink *l;
  992. int offset = 0;
  994.         if(! verbose ) return;
  996.         sprintf(logtarget_->pt_->buffer(),
  997.                 "T %.9f _%d_ neighbors: ", CURRENT_TIME, ipaddr);
  999. for(l = imepLinkHead.lh_first; l; l = l->link.le_next) {
  1000.   offset = strlen(logtarget_->pt_->buffer());
  1001.   sprintf(logtarget_->pt_->buffer() + offset,
  1002.   "%d%c ", l->index(),
  1003.   l->status() == LINK_BI ? '+' : 
  1004.     (l->status() == LINK_IN ? '-' : 
  1005.      (l->status() == LINK_OUT ? '|' : 'X')));
  1006. }
  1007.         logtarget_->pt_->dump();
  1008. }
  1010. void
  1011. imepAgent::trace(char* fmt, ...)
  1012. {
  1013.   va_list ap;
  1014.   
  1015.   if (!logtarget_) return;
  1017.   va_start(ap, fmt);
  1018.   vsprintf(logtarget_->pt_->buffer(), fmt, ap);
  1019.   logtarget_->pt_->dump();
  1020.   va_end(ap);
  1021. }
  1024. char *
  1025. imepAgent::dumpResponseList(Packet *p)
  1026. {
  1027.   static char buf[512];
  1028.   char *ptr = buf;
  1029.   struct imep_object_block *ob = findObjectBlock(p);
  1030.   struct imep_response *r = findResponseList(p);
  1031.   struct imep_response *r0;
  1032.   int i;
  1034.   for(i = 0, r0 = r; i < ob->ob_num_responses; i++, r0++) 
  1035.     {
  1036.       ptr += (int)sprintf(ptr,"%d ", INT32_T(r0->resp_ipaddr));
  1037.     }
  1038.   return buf;
  1039. }
  1042. void
  1043. imepAgent::Terminate()
  1044. {
  1045.   trace("IL %.9f _%d_ Add-Adj: %d New-Neigh: %d Del-Neigh1: %d Del-Neigh2: %d Del-Neigh3: %d",
  1046. CURRENT_TIME, ipaddr, 
  1047. stats.new_in_adjacency,
  1048. stats.new_neighbor      ,
  1049. stats.delete_neighbor1      ,
  1050. stats.delete_neighbor2,
  1051. stats.delete_neighbor3);
  1053.   trace("IL %.9f _%d_ Created QRY: %d UPD: %d CLR: %d",CURRENT_TIME, ipaddr,
  1054. stats.qry_objs_created      ,
  1055. stats.upd_objs_created      ,
  1056. stats.clr_objs_created);
  1058.   trace("IL %.9f _%d_ Received QRY: %d UPD: %d CLR: %d",CURRENT_TIME, ipaddr,
  1059. stats.qry_objs_recvd      ,
  1060. stats.upd_objs_recvd      ,
  1061. stats.clr_objs_recvd);
  1063.   trace("IL %.9f _%d_ Total-Obj-Created: %d Obj-Pkt-Created: %d Obj-Pkt-Recvd: %d",
  1064. CURRENT_TIME, ipaddr,
  1065. stats.num_objects_created      ,
  1066. stats.num_object_pkts_created      ,
  1067. stats.num_object_pkts_recvd);
  1069.   trace("IL %.9f _%d_ Rexmit Pkts: %d Acked: %d Retired: %d Rexmits: %d",
  1070. CURRENT_TIME, ipaddr,
  1071. stats.num_rexmitable_pkts      ,
  1072. stats.num_rexmitable_fully_acked      ,
  1073. stats.num_rexmitable_retired      ,
  1074. stats.num_rexmits);
  1077.   trace("IL %.9f _%d_ Sum-Response-List-Size Created: %d Retired: %d",
  1078. CURRENT_TIME, ipaddr,
  1079. stats.sum_response_list_sz      ,
  1080. stats.sum_rexmitable_retired_response_sz);
  1082.   trace("IL %.9f _%d_ Holes Created: %d Retired: %d ReSeqQ-Drops: %d ReSeqQ-Recvd: %d",
  1083. CURRENT_TIME, ipaddr,
  1084. stats.num_holes_created      ,
  1085. stats.num_holes_retired      ,
  1086. stats.num_reseqq_drops,
  1087. stats.num_recvd_from_queue);
  1089.   trace("IL %.9f _%d_ Unexpected-Acks: %d Out-Win-Obj: %d Out-Order-Obj: %d In-Order-Obj: %d", CURRENT_TIME, ipaddr,
  1090. stats.num_unexpected_acks      ,
  1091. stats.num_out_of_window_objs      ,
  1092. stats.num_out_of_order_objs      ,
  1093. stats.num_in_order_objs);
  1094. }