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

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

通讯编程

开发平台：

Visual C++

flood-agent.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1997,2000 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.  * @(#) $Header: /cvsroot/nsnam/ns-2/sensor-nets/flood-agent.cc,v 1.4 2000/09/01 03:04:11 haoboy Exp $
  35.  */
  37. // Author: Satish Kumar, kkumar@isi.edu
  39. #include <stdarg.h>
  40. #include <float.h>
  42. #include "flood-agent.h"
  43. #include <random.h>
  44. #include <cmu-trace.h>
  45. #include <address.h>
  47. #define OLD_QRY_ENTRY 0
  48. #define OLD_SHORTER_ENTRY 1
  49. #define NEW_QRY_ENTRY 2
  51. #define MAX_CACHE_ITEMS 200
  53. void FloodAgent::
  54. trace (char *fmt,...)
  55. {
  56.   va_list ap; // Define a variable ap that will refer to each argument in turn
  58.   if (!tracetarget_)
  59.     return;
  61.   // Initializes ap to first argument
  62.   va_start (ap, fmt); 
  63.   // Prints the elements in turn
  64.   vsprintf (tracetarget_->buffer (), fmt, ap); 
  65.   tracetarget_->dump ();
  66.   // Does the necessary clean-up before returning
  67.   va_end (ap); 
  68. }
  72. static class FloodAgentClass:public TclClass
  73. {
  74.   public:
  75.   FloodAgentClass ():TclClass ("Agent/flood")
  76.   {
  77.   }
  78.   TclObject *create (int, const char *const *)
  79.   {
  80.     return (new FloodAgent ());
  81.   }
  82. } class_flood_agent;
  86. FloodAgent::FloodAgent() : Agent(PT_MESSAGE)
  87. {
  88.   node_ = NULL;
  89.   tag_list_ = NULL;
  90.   query_list_ = NULL;
  92.   cache_ = 0; // Disable caching by default
  93.   tag_cache_ = new TagCache[MAX_CACHE_ITEMS];
  94.   num_cached_items_ = 0;
  95. }
  100. int 
  101. FloodAgent::command (int argc, const char *const *argv)
  102. {
  103.   if (argc == 2)
  104.     {
  105.       if (strcmp (argv[1], "start-floodagent") == 0)
  106.         {
  107.           startUp();
  108.           return (TCL_OK);
  109.         }
  110.       if (strcmp (argv[1], "enable-caching") == 0)
  111.         {
  112.           cache_ = 1;
  113.           return (TCL_OK);
  114.         }
  115.       else if (strcasecmp (argv[1], "ll-queue") == 0)
  116.         {
  117.   if (!(ll_queue = (PriQueue *) TclObject::lookup (argv[2])))
  118.             {
  119.               fprintf (stderr, "Flood_Agent: ll-queue lookup of %s failedn", argv[2]);
  120.               return TCL_ERROR;
  121.             }
  122.   return TCL_OK;
  123.         }
  124.     }
  125.   else if (argc == 3)
  126.     {
  127.       if (strcasecmp (argv[1], "tracetarget") == 0)
  128.         {
  129.           TclObject *obj;
  130.   if ((obj = TclObject::lookup (argv[2])) == 0)
  131.             {
  132.               fprintf (stderr, "%s: %s lookup of %s failedn", __FILE__, argv[1],
  133.                        argv[2]);
  134.               return TCL_ERROR;
  135.             }
  136.           tracetarget_ = (Trace *) obj;
  137.           return TCL_OK;
  138.         }
  139.       else if (strcasecmp (argv[1], "addr") == 0) {
  140.         int temp;
  141.         temp = Address::instance().str2addr(argv[2]);
  142.         myaddr_ = temp;
  143.         return TCL_OK;
  144.       }
  145.       else if (strcasecmp (argv[1], "attach-tag-dbase") == 0)
  146.         {
  147.           TclObject *obj;
  148.   if ((obj = TclObject::lookup (argv[2])) == 0)
  149.             {
  150.               fprintf (stderr, "%s: %s lookup of %s failedn", __FILE__, argv[1],
  151.                        argv[2]);
  152.               return TCL_ERROR;
  153.             }
  154.           tag_dbase_ = (tags_database *) obj;
  155.           return TCL_OK;
  156.         }
  157.       else if (strcasecmp (argv[1], "node") == 0)
  158.         {
  159.           assert(node_ == NULL);
  160.           TclObject *obj;
  161.   if ((obj = TclObject::lookup (argv[2])) == 0)
  162.             {
  163.               fprintf (stderr, "%s: %s lookup of %s failedn", __FILE__, argv[1],
  164.                        argv[2]);
  165.               return TCL_ERROR;
  166.             }
  167.           node_ = (MobileNode *) obj;
  168.           return TCL_OK;
  169.         }
  170.     }
  171.   
  172.   return (Agent::command (argc, argv));
  173. }
  179. void
  180. FloodAgent::startUp()
  181. {
  182.   compr_taglist *local_tags0, *t_ptr;
  183.   int ntags = 0;
  184.   double x,y,z;
  186.   node_->getLoc(&x,&y,&z);
  187.   //  printf("Node %d position: (%f,%f,%f)n",myaddr_,x,y,z);
  189.   // Detection range smaller than transmission range. This is because, if 
  190.   // the tags are passive, they may not have sufficient energy to re-radiate
  191.   // information to the sensor
  192.   double r = 60;
  194.   local_tags0 = tag_dbase_->Gettags(x,y,r);
  195.   trace("Node %d's at (%f,%f,%f) senses tags:",myaddr_,x,y,z);
  196.   t_ptr = local_tags0;
  197.   ntags = 0;
  198.   while(t_ptr) {
  199.     trace("tag name: %d.%d.%d",(t_ptr->obj_name_ >> 24) & 0xFF,(t_ptr->obj_name_ >> 16) & 0xFF,(t_ptr->obj_name_) & 0xFFFF);
  200.     ++ntags;
  201.     t_ptr = t_ptr->next_;
  202.   }
  203.   trace("Number of tags: %d",ntags);
  205.   tag_list_ = local_tags0;
  207. }
  209. void
  210. FloodAgent::recv(Packet *p, Handler *)
  211. {
  212.   hdr_ip *iph = HDR_IP(p);
  213.   hdr_cmn *cmh = HDR_CMN(p);
  214.   unsigned char *walk, *X_ptr, *Y_ptr;
  215.   compr_taglist *tag_ptr;
  216.   int found = FALSE, action, X, Y, obj_name, origin_time, next_hop_level;
  217.   int cached = FALSE, cache_index = -1;
  218.   int num_src_hops;
  219.   double local_x, local_y, local_z;
  220.   nsaddr_t last_hop_id;
  221.   Scheduler &s = Scheduler::instance();
  222.   double now = s.clock();
  224.   walk = p->accessdata();
  226.   // Type of advertisement
  227.   action = *walk++;
  229.   X_ptr = walk;
  230.   X = *walk++;
  231.   X = (X << 8) | *walk++;
  233.   Y_ptr = walk;
  234.   Y = *walk++;
  235.   Y = (Y << 8) | *walk++;
  237.   // Used in LM
  238.   next_hop_level = *walk++;
  240.   obj_name = *walk++;
  241.   obj_name = (obj_name << 8) | *walk++;
  242.   obj_name = (obj_name << 8) | *walk++;
  243.   obj_name = (obj_name << 8) | *walk++;
  245.     // origin time of advertisement
  246.   origin_time = *walk++;
  247.   origin_time = (origin_time << 8) | *walk++;
  248.   origin_time = (origin_time << 8) | *walk++;
  249.   origin_time = (origin_time << 8) | *walk++;
  251.   num_src_hops = *walk++;
  252.   num_src_hops = (num_src_hops << 8) | *walk++;
  254.   // Query from an agent at our node
  255.   if(iph->saddr() == myaddr_ && iph->sport() == 0 && action == QUERY_PKT) {
  256.     // Increase the number of source hops to 1
  257.     // Add IP header length
  258.     cmh->size_ += 20;
  259.   }
  260.   else {
  261.     ++num_src_hops;
  262.     walk = walk - 2;
  263.     (*walk++) = (num_src_hops >> 8) & 0xFF;
  264.     (*walk++) = (num_src_hops) & 0XFF;
  265.   }
  266.     
  267.   if(num_src_hops) {
  268.     last_hop_id = *walk++;
  269.     last_hop_id = (last_hop_id << 8) | *walk++;
  270.   }
  271.   else {
  272.     last_hop_id = myaddr_;
  273.     walk = walk + 2;
  274.   }
  276.   if(action == QUERY_PKT) {
  277.     walk = walk - 2;
  278.     *walk++ = (myaddr_ >> 8) & 0xFF;
  279.     *walk++ = myaddr_ & 0xFF;
  280.   }
  282.   // Packet will be send down the stack
  283.   cmh->direction() = hdr_cmn::DOWN;
  286.   // Query pkt if X and Y are 65000
  287.   if(X == 65000 && Y == 65000) {
  289.     // Method returns 1 if query seen before. Otherwise returns 0
  290.     // and adds query info to the list
  291.     int query_type = search_queries_list(iph->saddr(),obj_name,origin_time,num_src_hops,last_hop_id);
  292.     if(query_type == OLD_QRY_ENTRY) {
  293.       Packet::free(p);
  294.       return;
  295.     }
  297.     // Check if info is in cache if caching is enabled
  298.     if(cache_) {
  299.             // If this is a query pkt; check if we have the relevant information 
  300.       // cached. TTL = 600 seconds for the cache entries
  301.       cached = FALSE;
  302.       for(int i = 0; i < num_cached_items_; ++i) {
  303.         if(tag_cache_[i].obj_name_ == obj_name && tag_cache_[i].origin_time_ > origin_time - 600) {
  304.           cached = TRUE;
  305.           cache_index = i;
  306.           break;
  307.         }
  308.       }
  309.     }
  312.     // check if our node has the requested information
  313.     tag_ptr = tag_list_;
  314.     while(tag_ptr) {
  315.       if(tag_ptr->obj_name_ == obj_name) {
  316. found = TRUE;
  317. break;
  318.       }
  319.       tag_ptr = tag_ptr->next_;
  320.     }
  321.     
  322.     if(query_type == OLD_SHORTER_ENTRY && found) {
  323.       trace("Node %d: Query received along shorter path",myaddr_);
  324.       Packet::free(p);
  325.       return;
  326.     }
  327.     
  328.     if(found || cached) {
  329.       // generate response
  330.       //      trace("Node %d: Generating response",myaddr_);
  331.       if(cached) {
  332.           (*X_ptr++) = ((int)tag_cache_[cache_index].X_ >> 8) & 0xFF;
  333.           (*X_ptr) = ((int)tag_cache_[cache_index].X_) & 0xFF;
  334.           (*Y_ptr++) = ((int)tag_cache_[cache_index].Y_ >> 8) & 0xFF;
  335.           (*Y_ptr) = ((int)tag_cache_[cache_index].Y_) & 0xFF;
  336.       }
  337.       else {
  338. node_->getLoc(&local_x, &local_y, &local_z);
  339. (*X_ptr++) = ((int)local_x >> 8) & 0xFF;
  340. (*X_ptr) = ((int)local_x) & 0xFF;
  341. (*Y_ptr++) = ((int)local_y >> 8) & 0xFF;
  342. (*Y_ptr) = ((int)local_y) & 0xFF;
  343.       }
  345.       iph->ttl_ = 1000;
  346.       iph->daddr() = iph->saddr();
  347.       iph->dport() = QUERY_PORT;
  348.       cmh->next_hop() = last_hop_id;
  349.       cmh->addr_type_ = NS_AF_INET;
  350.       // Add 50 bytes to response 
  351.       cmh->size() += 50;
  353.       if(last_hop_id == myaddr_) {
  354. // TEMPORARY HACK! Cant forward from routing agent to some other
  355. // agent on our node!
  356. Packet::free(p);
  357. trace("FloodAgent Found object %d.%d.%d at (%d,%d) at time %f", (obj_name >> 24) & 0xFF, (obj_name >> 16) & 0xFF, obj_name & 0xFFFF,X,Y,now);
  358. return;
  359.       }
  361.       s.schedule(target_,p,0);
  362.     }
  363.     else {
  364.       // flood pkt 
  365.       //      trace("Node %d: Flooding packet; query type %d",myaddr_,query_type);
  366.       if(--iph->ttl_ == 0) {
  367. drop(p, DROP_RTR_TTL);
  368. return;
  369.       }
  371.       cmh->next_hop_ = IP_BROADCAST; // need to broadcast packet
  372.       cmh->addr_type_ = NS_AF_INET;
  373.       iph->daddr() = IP_BROADCAST;  // packet needs to be broadcast
  374.       iph->dport() = ROUTER_PORT;
  376.       s.schedule(target_,p,0);
  377.     }
  378.   }
  379.   else {
  380.     // Forward response
  381.     //    trace("Node %d: Forwarding response",myaddr_);
  382.     if(--iph->ttl_ == 0) {
  383.       drop(p, DROP_RTR_TTL);
  384.       return;
  385.     }
  386.     
  387.     if(cache_) {
  388.       if(num_cached_items_ < MAX_CACHE_ITEMS) {
  390. int replace_index = num_cached_items_;
  391. // If object already exists in cache, update info if necessary
  392. for(int i = 0; i < num_cached_items_; ++i) {
  393.   if(tag_cache_[i].obj_name_ == obj_name && tag_cache_[i].origin_time_ < origin_time) {
  394.     replace_index = i;
  395.     break;
  396.   }
  397. }
  399. tag_cache_[replace_index].obj_name_ = obj_name;
  400. tag_cache_[replace_index].origin_time_ = origin_time;
  401. tag_cache_[replace_index].X_ = X;
  402. tag_cache_[replace_index].Y_ = Y;
  403. ++num_cached_items_;
  404.       }
  405.       else {
  406. // Use LRU cache replacement
  407. int replace_index = 0;
  408. int least_time = tag_cache_[replace_index].origin_time_;
  409. for(int i = 0; i < MAX_CACHE_ITEMS; ++i) {
  410.   if(tag_cache_[i].origin_time_ < least_time)
  411.     replace_index = i;
  412. }
  413. tag_cache_[replace_index].obj_name_ = obj_name;
  414. tag_cache_[replace_index].origin_time_ = origin_time;
  415. tag_cache_[replace_index].X_ = X;
  416. tag_cache_[replace_index].Y_ = Y;
  417.       }
  418.     }
  419.     
  420.     cmh->next_hop_ = get_next_hop(iph->saddr(),obj_name,origin_time);
  421.     assert(cmh->next_hop_ != NO_NEXT_HOP);
  422.     s.schedule(target_,p,0);
  423.   }
  424. }
  429. int
  430. FloodAgent::search_queries_list(nsaddr_t src, int obj_name, int origin_time, int num_hops, nsaddr_t last_hop_id)
  431. {
  432.   QueryList *ql, *newql = NULL, *replql = NULL;
  434.   ql = query_list_;
  436.   while(ql) {
  437.     if(ql->src_ == src && ql->obj_name_ == obj_name && ql->origin_time_ == origin_time) {
  438.       if(ql->num_hops_ > num_hops) {
  439. ql->num_hops_ = num_hops;
  440. ql->last_hop_id_ = last_hop_id;
  441.       return(OLD_SHORTER_ENTRY);
  442.       }
  443.       return(OLD_QRY_ENTRY);
  444.     }
  445.     // Replace very old entries
  446.     if(ql->origin_time_ + 100 < origin_time && !replql)
  447.       replql = ql;
  448.     else if(!replql)
  449.       newql = ql;
  450.     ql = ql->next_;
  451.   }    
  453.   if(!query_list_) {
  454.     query_list_ = new QueryList;
  455.     query_list_->src_ = src;
  456.     query_list_->obj_name_ = obj_name;
  457.     query_list_->origin_time_ = origin_time;
  458.     query_list_->num_hops_ = num_hops;
  459.     query_list_->last_hop_id_ = last_hop_id;
  460.     return(NEW_QRY_ENTRY);
  461.   }
  463.   if(replql) {
  464.     replql->src_ = src;
  465.     replql->obj_name_ = obj_name;
  466.     replql->origin_time_ = origin_time;
  467.     replql->num_hops_ = num_hops;
  468.     replql->last_hop_id_ = last_hop_id;
  469.   }
  470.   else {
  471.     newql->next_ = new QueryList;
  472.     newql = newql->next_;
  473.     newql->src_ = src;
  474.     newql->obj_name_ = obj_name;
  475.     newql->origin_time_ = origin_time;
  476.     newql->num_hops_ = num_hops;
  477.     newql->last_hop_id_ = last_hop_id;
  478.   }
  479.   return(NEW_QRY_ENTRY);
  480. }
  481.   
  484. nsaddr_t
  485. FloodAgent::get_next_hop(nsaddr_t src, int obj_name, int origin_time)
  486. {
  487.  QueryList *ql;
  489.  ql = query_list_;
  491.  while(ql) {
  492.    if(ql->src_ == src && ql->obj_name_ == obj_name && ql->origin_time_ == origin_time) {
  493.      return(ql->last_hop_id_);
  494.    }
  495.    ql = ql->next_;
  496.  }
  497.  
  498.  return(NO_NEXT_HOP);
  499. }
  501.