ns-2.29-aodv-uu-0.9.1-dsr-uu-0.2-oolsr-0.99.15.patch

无线自组织网络协议

+  ch->iface() = -2;
+  ch->error() = 0;
+  ch->addr_type() = NS_AF_NONE;
+  ch->prev_hop_ = srcAddress;
+  ch->next_hop_ = dstAddress; 
+
+  ih->saddr() = srcAddress;
+  ih->daddr() = dstAddress;
+  ih->sport() = RT_PORT;
+  ih->dport() = RT_PORT;
+  ih->ttl_ = PLUGIN_PROTOCOL_PACKET_TTL;
+
+  memcpy(p->accessdata(), packetData, packetSize);
+
+  target_->recv(p, (Handler*)0);
+}
+
+//---------------------------------------------------------------------------
+
+
+//---------------------------------------------------------------------------
+
+static void* pluginLibrary = NULL;
+PPA_PluginApi* pluginApi = NULL;
+char* nodeConfig = NULL;
+
+LoadPluginCommand::LoadPluginCommand() : TclCommand("load-plugin")
+{
+  memset(&simulatorApi, 0, sizeof(simulatorApi));
+  simulatorApi.addressSize = sizeof(nsaddr_t);
+  simulatorApi.getBroadcastAddressFunction = getBroadcastAddress;
+  simulatorApi.scheduleAtFunction = scheduleAt;
+  simulatorApi.sendPacketFunction = sendPacket;
+  simulatorApi.getCurrentTimeFunction = getCurrentTime;
+  simulatorApi.configureRouteFunction = configureRoute;
+  simulatorApi.getExtension = NULL;
+  initMulticastExtension(simulatorApi);
+}
+
+extern "C" void loadPlugin(char* fileName,
+                           PPA_PlugeeApi* myApi, PPA_PluginApi** pluginApi);
+
+int LoadPluginCommand::command(int argc, const char* const* argv)
+{
+  Tcl& tcl = Tcl::instance();
+  if(argc < 2) {
+    tcl.add_error("load-plugin requires at least one argument.");
+    return TCL_ERROR;
+  }
+  if (argc >= 2) {
+    debugPlugin = true;
+    for(int i=2; i<argc;i++) {
+       if (!strcmp(argv[i],"--output") && (i+1<argc) ) {
+	  assert(i+1 < argc);
+	  out = new std::ofstream(argv[i+1]);
+	  i++;
+       } else debugLevel.insert(argv[i]);
+      //D(cout << "[plugin] Added debug: " << argv[i] << endl);
+    }
+    //nodeConfig = strdup((char*)(argv[2])); // XXX: free
+  }
+
+  char* fileName = (char*)(argv[1]); 
+
+#ifndef NEW_STATIC_STUFF
+  // If a plugin is already loaded, unload it.
+  if(pluginLibrary != NULL) {
+    dlclose(pluginLibrary);
+    pluginLibrary = NULL;
+    pluginApi = NULL;
+  }
+
+  //void* pluginLibrary = NULL;
+  pluginLibrary = dlopen(fileName, RTLD_NOW);
+  if(!pluginLibrary) {
+    char* newFileName = new char[strlen(fileName)+1+strlen(".so")];
+    strcpy(newFileName, fileName);
+    strcat(newFileName, ".so");
+    pluginLibrary = dlopen(newFileName, RTLD_NOW);
+    delete [] newFileName;
+  }
+  if(!pluginLibrary) {
+    tcl.resultf("load-plugin: cannot open library file '%s': %s", 
+		fileName, dlerror());
+    return TCL_ERROR;
+  }
+  
+  PPA_ProtocolPluginApiInitFunc pluginInitFunc = 
+    (PPA_ProtocolPluginApiInitFunc) dlsym(pluginLibrary, PPA_InitFunctionName);
+  if(pluginInitFunc == NULL) {
+    tcl.resultf("load-protocol-plugin: cannot find init function in plugin");
+    dlclose(pluginLibrary);
+    return TCL_ERROR;
+  }
+
+  int status = pluginInitFunc(PPA_VERSION_MAJOR, PPA_VERSION_MINOR,
+			      &simulatorApi, &pluginApi);
+  if (status != PPA_OK) {
+    tcl.resultf("load-protocol-plugin: init function of plugin returned FAILURE");
+    dlclose(pluginLibrary);
+    return TCL_ERROR;
+  }
+
+  tcl.resultf("%s", fileName);
+#else
+  // XXX: this doesn't work yet
+  loadPlugin(fileName, &simulatorApi, &pluginApi);
+  tcl.resultf("%d", doesRequirePlugin());
+#endif
+
+  return TCL_OK;
+}
+
+//---------------------------------------------------------------------------
+
+PluginAgent::PluginAgent(nsaddr_t id) : Agent(PT_PLUGIN), index_(id)
+{
+  assert(pluginApi != NULL);
+  routeList = NULL;
+  pluginProtocolNode = NULL; 
+  configData = (void*) strdup("");
+  configSize = 0;
+}
+
+#if 0
+void deleteRoutingTable(ProtocolRoutingTable* routingTable)
+{
+  for(int i=0;i<routingTable->size;i++) {
+    delete [] ((char*)routingTable->destinationAddress[i]);
+    delete [] ((char*)routingTable->nextHopAddress[i]);
+  }
+  delete [] routingTable->destinationAddress;
+  delete [] routingTable->nextHopAddress;
+  delete [] routingTable->distance;
+  routingTable->destinationAddress = NULL;
+  routingTable->nextHopAddress = NULL;
+  routingTable->distance = NULL;
+  routingTable->size = -1;
+  delete routingTable;
+}
+#endif
+
+bool PluginAgent::configureRoute(PPA_Route* route, int command)
+{
+  if (command == PPA_DEL_ROUTE) {
+     
+    ProtocolRouteCell** listPtr = &routeList;
+    while(*listPtr != NULL 
+	  && ( ((*listPtr)->destinationAddress 
+		!= *(nsaddr_t*)(route->destinationAddress))
+	       || ((*listPtr)->nextHopAddress
+		   != *(nsaddr_t*)(route->nextHopInterfaceAddress))))
+      listPtr = &((*listPtr)->next);
+    if (*listPtr == NULL)
+      return false;
+    Dl("route", char s[4096]; 
+       sprintf(s,"%f [plugin] node#%d: del route: % 3d->% 3d\n", 
+	       Scheduler::instance().clock(),
+	       (unsigned int)index_, (*listPtr)->nextHopAddress,
+	       (*listPtr)->destinationAddress);
+       (*out)<<s);
+
+    ProtocolRouteCell* current = *listPtr;
+    *listPtr = (*listPtr)->next;
+    delete current;
+
+  } else if (command == PPA_ADD_ROUTE) {
+     
+    ProtocolRouteCell* cell = new ProtocolRouteCell;
+    cell->next = routeList;
+    cell->destinationAddress = *(nsaddr_t*)(route->destinationAddress);
+    cell->nextHopAddress = *(nsaddr_t*)(route->nextHopInterfaceAddress);
+    routeList = cell;
+    Dl("route", char s[4096]; 
+       sprintf(s,"%f [plugin] node#%d: add route: % 3d->% 3d\n",
+	       Scheduler::instance().clock(),
+	       (unsigned int)index_, cell->nextHopAddress,
+	       cell->destinationAddress);
+       (*out)<<s );
+     
+  } else return false;
+   
+  return true;
+}
+
+//XXX! need to check the number of arguments!
+int PluginAgent::command(int argc, const char*const* argv)
+{
+  Tcl &tcl = Tcl::instance();
+
+  //------------------------------
+  if (!strcmp(argv[1], "start")) {
+    if (argc != 2) {
+      tcl.resultf("Invalid number of arguments");
+      return TCL_ERROR;
+    }
+    if(pluginProtocolNode == NULL) {
+      void* addressList = (void*)&index_;
+      int mtu = PLUGIN_PROTOCOL_MTU;
+      if ((nodeConfig != NULL) && (configSize == 0)) {
+	// This is a hack
+	free(configData);
+	configData = strdup(nodeConfig); // XXX: free
+	configSize = strlen(nodeConfig);
+      }
+      Dl("config", ME << "started node with config:" << (char*)configData
+	 << endl);
+      pluginProtocolNode = pluginApi->createNodeFunction
+	((void*)this, 1, &addressList, &mtu,
+	 configData, configSize);
+    }
+    pluginApi->nodeStartFunction(pluginProtocolNode);
+    return TCL_OK;
+
+    //------------------------------
+  } else if (!strcmp(argv[1], "set-config")) {
+    if (argc != 3) {
+      tcl.resultf("Invalid number of arguments");
+      return TCL_ERROR;
+    }
+    free(configData);
+    configData = strdup(argv[2]); // XXX: need to free this
+    configSize = strlen(argv[2]);
+    //std::cout << "Node config: " << configData << std::endl;
+    return TCL_OK;
+
+    //------------------------------
+  } else if (!strcmp(argv[1], "state")) {
+    if (argc != 2 && argc != 3) {
+      tcl.resultf("Invalid number of arguments");
+      return TCL_ERROR;
+    }
+    char* result = NULL;
+    pluginApi->nodeWriteFunction(pluginProtocolNode, &result);
+    if (argc != 3) {
+      tcl.resultf("%s", result);
+      free(result);
+    } else {
+      std::ofstream out(argv[2]);
+      out << result;
+      free(result);
+      tcl.resultf("");
+    }
+    return TCL_OK;
+
+    //------------------------------
+  } else if (!strcmp(argv[1], "add-config")) {
+    if (argc != 3) {
+      tcl.resultf("Invalid number of arguments");
+      return TCL_ERROR;
+    }
+    char* tmp = (char*)malloc(strlen((char*)configData) + 1 
+			      + strlen(argv[2]) + 1);
+    strcpy(tmp, (char*)configData);
+    strcat(tmp, "\n");
+    strcat(tmp, argv[2]);
+    free(configData);
+    configData = tmp; // XXX: need to free this
+    configSize = strlen((char*)configData);
+    (*out) << "Node config: " << configData << std::endl;
+    return TCL_OK;
+
+    //------------------------------
+  } else if(!strcmp(argv[1], "log-target") 
+	    || !strcmp(argv[1], "tracetarget")) {
+    if (argc != 3) {
+      tcl.resultf("Invalid number of arguments");
+      return TCL_ERROR;
+    }
+    Trace* logtarget = (Trace*) TclObject::lookup(argv[2]);
+    if(logtarget == NULL) return TCL_ERROR;
+    else return TCL_OK;
+
+    //------------------------------
+  } else if (!strcmp(argv[1], "port-dmux")) {
+    if (argc != 3) {
+      tcl.resultf("Invalid number of arguments");
+      return TCL_ERROR;
+    }
+    dmux_ = (PortClassifier*) TclObject::lookup(argv[2]);
+    if (dmux_ == 0) {
+      fprintf (stderr, "%s: %s lookup of %s failed\n", __FILE__,
+               argv[1], argv[2]);
+      return TCL_ERROR;
+    }
+    return TCL_OK;
+  }
+  return (Agent::command(argc, argv));
+}
+
+void PluginAgent::recv(Packet* packet, Handler* handler)
+{
+  struct hdr_cmn *ch = HDR_CMN(packet); // COMMON header
+  struct hdr_ip *ih = HDR_IP(packet); // IP header
+
+  // I added this just to be safe, I don't now why
+  if (ch->ptype() != PT_PLUGIN && ch->direction() == hdr_cmn::UP &&
+      ((u_int32_t)ih->daddr() == IP_BROADCAST)
+      || ((u_int32_t)ih->daddr() == here_.addr_)) {
+    dmux_->recv(packet,0);
+    return;
+  }
+
+  //if (ih->saddr() != index_ || ch->
+  if (ch->ptype() == PT_PLUGIN) {
+    // Protocol packet:
+    PPA_Packet protocolPacket;
+    protocolPacket.size = packet->datalen();
+    protocolPacket.data = malloc(protocolPacket.size);
+    memcpy(protocolPacket.data, packet->accessdata(), 
+	   protocolPacket.size);
+    nsaddr_t senderAddress = ih->saddr();
+    pluginApi->nodeReceiveFunction(pluginProtocolNode,
+				   &senderAddress,
+				   (void*)&index_, // XXX: one interface
+				   protocolPacket);
+    Dl("protocol-packet", ME << "protocol packet received from node#"
+       << ((unsigned int)senderAddress)
+       << ", size " << protocolPacket.size << endl);
+    Packet::free(packet);
+
+  } else { 
+
+    if (ih->saddr() == index_) {
+      // A packet originating from this node
+
+      if (ch->num_forwards() == 0) {
+	// It was just send by a local agent: never forwarded yet
+	// update the headers.
+	ch->size() += IP_HDR_LEN; // add header size : XXX: check
+	ih->ttl_ = PLUGIN_PROTOCOL_PACKET_TTL; // XXX: other TTL
+	Dl("data-packet", ME << "data packet from ourself, uid="
+	   << ch->uid() << " size=" << ch->size() << endl);
+	// XXX: is this ok?, or return ?
+
+	bool processed = (processLocalPacketExtension(packet));
+	if (processed)
+	  return;
+
+      } else {
+	// a loop leading to yourself - drop it.
+	Dll("data-packet", "packet-drop", 
+	    ME << "self-loop - packet dropped\n");
+	// XXX: MAODV does Packet::free(p) when it is a multicast packet
+	drop(packet, DROP_RTR_ROUTE_LOOP);
+	return;
+      }
+    } else {
+      // A packet from another node:
+      // Attempt forwarding
+      ih->ttl_ --;
+      if(ih->ttl_ <=0) {
+	Dll("packet-drop", "data-packet", ME << "ttl=0 - packet dropped\n");
+      	drop(packet, DROP_RTR_TTL);
+	return;
+      } 
+    }
+    
+    ProtocolRouteCell* currentRoute = routeList;
+    while(currentRoute != NULL 
+	  && (currentRoute->destinationAddress != ih->daddr()))
+      currentRoute = currentRoute->next;
+     Dl("forward-table",
+	char s[4096];
+	sprintf(s, "[plugin] node#%d - routing table: \n", 
+	       (unsigned int)index_);
+	(*out)<<s;
+	for(ProtocolRouteCell* currentRoute = routeList;currentRoute != NULL;
+	    currentRoute=currentRoute->next) {
+	   sprintf(s, "  % 3d->% 3d\n", currentRoute->nextHopAddress,
+		   currentRoute->destinationAddress);
+	   (*out)<<s;
+	});
+     
+    if (currentRoute != NULL) {
+      Dl("data-packet",
+	 char s[4096];
+	 sprintf(s,"[plugin] node#%d - % 3d->% 3d via % 3d"
+		 "- packet forwarded\n", 
+		 (unsigned int)index_, 
+		 (unsigned int)(ih->saddr()),
+		 (unsigned int)(ih->daddr()),
+		 (unsigned int)(currentRoute->nextHopAddress));
+	 (*out)<<s);
+       
+      forward(currentRoute->nextHopAddress, packet);
+    } else {
+      Dll("data-packet", "packet-drop",
+	  char s[4096];	  
+	  sprintf(s, "[plugin] node#%d - no next hop for % 3d->% 3d "
+		  "- packet dropped\n",
+		  (unsigned int)index_, 
+		  (unsigned int)(ih->saddr()),
+		  (unsigned int)(ih->daddr()));
+	  (*out)<<s);
+      
+      drop(packet, DROP_RTR_NO_ROUTE);
+    }    
+  }
+}
+
+void PluginAgent::forward(nsaddr_t nextHopAddress, Packet* packet)