NS2相关学习——完成一个新协议（2）

最新推荐文章于 2019-03-31 21:05:45 发布

植齿添牙

最新推荐文章于 2019-03-31 21:05:45 发布

阅读量367

点赞数 1

分类专栏： NS2

NS2 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

在上节中，我们把教程要求的3.1-3.3过了一遍，这一次回到正途上来。看看到底是怎么完成一个新的协议的。

本节中的代码实现了一些简单的“ping”协议（灵感来自“ns注释和文档”（现在更名为ns手册）的第9.6章中的“ping请求者”，但相当不同）。一个节点将能够发送一个数据包到另一个节点，它将立即返回，以便可以计算往返时间。

1、头文件

在新的头文件'ping.h'中，首先必须声明将携带相关数据的新的Ping包头的数据结构。

struct hdr_ping {
  char ret;
  double send_time;
};

如果数据包正在从发送方正在被ping通的节点上，则char'ret'将被设置为“0”，而在返回路由时将被设置为“1”。 double “send_time”是发送时在分组上设置的时间戳，用于后来计算往返时间。

以下代码段将类“PingAgent”声明为类“Agent”的子类。

class PingAgent : public Agent {
 public:
  PingAgent();
  int command(int argc, const char*const* argv);
  void recv(Packet*, Handler*);
 protected:
  int off_ping_;  
};

int off_ping_将用于访问数据包的ping头。请注意，对于具有本地对象范围的变量通常使用尾随“_”。

在下面的部分中，将介绍定义构造函数“PingAgent（）”的C ++代码以及在本声明中重新定义的函数'command（）'和'recv（）'。

2、c++代码

首先必须定义C ++代码和Tcl代码之间的联系。

首先，定义了协议头类以及应用类（C++中）


static class PingHeaderClass : public PacketHeaderClass {
public:
  PingHeaderClass() : PacketHeaderClass("PacketHeader/Ping", 
                                        sizeof(hdr_ping)) {}
} class_pinghdr;


static class PingClass : public TclClass {
public:
  PingClass() : TclClass("Agent/Ping") {}
  TclObject* create(int, const char*const*) {
    return (new PingAgent());
  }
} class_ping;

下一段代码是类“PingAgent”的构造函数。它绑定了必须在Tcl和C ++中访问的变量。TCL中的（packetSize）——>C++（size）

PingAgent::PingAgent() : Agent(PT_PING)
{
  bind("packetSize_", &size_);
  bind("off_ping_", &off_ping_);
}

当执行类“PingAgent”的Tcl命令时，将调用函数'command（）'。在本案例中，将是'$ pa send'（假设'pa'是Agent / Ping类的一个实例），因为我们希望将ping数据包从代理发送到另一个ping代理。我们基本上必须在'command（）'函数中解析命令，如果没有匹配，则必须将其参数传递给基类的command（）函数（在这种情况下为“代理” ：：命令（）'（详见代码倒数第二行的return））

int PingAgent::command(int argc, const char*const* argv)
{
  if (argc == 2) {
    if (strcmp(argv[1], "send") == 0) {
      // Create a new packet
      Packet* pkt = allocpkt();
      // Access the Ping header for the new packet:
      hdr_ping* hdr = (hdr_ping*)pkt->access(off_ping_);
      // Set the 'ret' field to 0, so the receiving node knows
      // that it has to generate an echo packet
      hdr->ret = 0;
      // Store the current time in the 'send_time' field
      hdr->send_time = Scheduler::instance().clock();
      // Send the packet
      send(pkt, 0);
      // return TCL_OK, so the calling function knows that the
      // command has been processed
      return (TCL_OK);
    }
  }
  // If the command hasn't been processed by PingAgent()::command,
  // call the command() function for the base class
  return (Agent::command(argc, argv));
}

函数recv（）定义了接收到数据包时要执行的操作。如果'ret'字段为0，则必须返回“send_time”字段的值相同但“ret”字段设置为1的数据包。如果'ret'为1，则会调用Tcl函数（必须由Tcl中的用户定义）函数并处理该事件。

void PingAgent::recv(Packet* pkt, Handler*)
{
  // Access the IP header for the received packet:
  hdr_ip* hdrip = (hdr_ip*)pkt->access(off_ip_);
  // Access the Ping header for the received packet:
  hdr_ping* hdr = (hdr_ping*)pkt->access(off_ping_);
  // Is the 'ret' field = 0 (i.e. the receiving node is being pinged)?
  if (hdr->ret == 0) {
    // Send an 'echo'. First save the old packet's send_time
    double stime = hdr->send_time;
    // Discard the packet
    Packet::free(pkt);
    // Create a new packet
    Packet* pktret = allocpkt();    
    // Access the Ping header for the new packet:
    hdr_ping* hdrret = (hdr_ping*)pktret->access(off_ping_);
    // Set the 'ret' field to 1, so the receiver won't send another echo
    hdrret->ret = 1;                
    // Set the send_time field to the correct value
    hdrret->send_time = stime;      
    // Send the packet              
    send(pktret, 0);                
  } else {                          
    // A packet was received. Use tcl.eval to call the Tcl
    // interpreter with the ping results.
    // Note: In the Tcl code, a procedure 'Agent/Ping recv {from rtt}'
    // has to be defined which allows the user to react to the ping
    // result.                      
    char out[100];                  
    // Prepare the output to the Tcl interpreter. Calculate the round
    // trip time                    
    sprintf(out, "%s recv %d %3.1f", name(), 
            hdrip->src_.addr_ >> Address::instance().NodeShift_[1],
            (Scheduler::instance().clock()-hdr->send_time) * 1000);
    Tcl& tcl = Tcl::instance();     
    tcl.eval(out);                  
    // Discard the packet           
    Packet::free(pkt);              
  }                                 
}

完整代码：

/*
 * File: Code for a new 'Ping' Agent Class for the ns
 *       network simulator
 * Author: Marc Greis (greis@cs.uni-bonn.de), May 1998
 *
 */


#include "ping.h"


static class PingHeaderClass : public PacketHeaderClass {
public:
  PingHeaderClass() : PacketHeaderClass("PacketHeader/Ping", 
					sizeof(hdr_ping)) {}
} class_pinghdr;


static class PingClass : public TclClass {
public:
  PingClass() : TclClass("Agent/Ping") {}
  TclObject* create(int, const char*const*) {
    return (new PingAgent());
  }
} class_ping;


PingAgent::PingAgent() : Agent(PT_PING)
{
  bind("packetSize_", &size_);
  bind("off_ping_", &off_ping_);
}


int PingAgent::command(int argc, const char*const* argv)
{
  if (argc == 2) {
    if (strcmp(argv[1], "send") == 0) {
      // Create a new packet
      Packet* pkt = allocpkt();
      // Access the Ping header for the new packet:
      hdr_ping* hdr = (hdr_ping*)pkt->access(off_ping_);
      // Set the 'ret' field to 0, so the receiving node knows
      // that it has to generate an echo packet
      hdr->ret = 0;
      // Store the current time in the 'send_time' field
      hdr->send_time = Scheduler::instance().clock();
      // Send the packet
      send(pkt, 0);
      // return TCL_OK, so the calling function knows that the
      // command has been processed
      return (TCL_OK);
    }
  }
  // If the command hasn't been processed by PingAgent()::command,
  // call the command() function for the base class
  return (Agent::command(argc, argv));
}


void PingAgent::recv(Packet* pkt, Handler*)
{
  // Access the IP header for the received packet:
  hdr_ip* hdrip = (hdr_ip*)pkt->access(off_ip_);
  // Access the Ping header for the received packet:
  hdr_ping* hdr = (hdr_ping*)pkt->access(off_ping_);
  // Is the 'ret' field = 0 (i.e. the receiving node is being pinged)?
  if (hdr->ret == 0) {
    // Send an 'echo'. First save the old packet's send_time
    double stime = hdr->send_time;
    // Discard the packet
    Packet::free(pkt);
    // Create a new packet
    Packet* pktret = allocpkt();
    // Access the Ping header for the new packet:
    hdr_ping* hdrret = (hdr_ping*)pktret->access(off_ping_);
    // Set the 'ret' field to 1, so the receiver won't send another echo
    hdrret->ret = 1;
    // Set the send_time field to the correct value
    hdrret->send_time = stime;
    // Send the packet
    send(pktret, 0);
  } else {
    // A packet was received. Use tcl.eval to call the Tcl
    // interpreter with the ping results.
    // Note: In the Tcl code, a procedure 'Agent/Ping recv {from rtt}'
    // has to be defined which allows the user to react to the ping
    // result.
    char out[100];
    // Prepare the output to the Tcl interpreter. Calculate the round
    // trip time
    sprintf(out, "%s recv %d %3.1f", name(), 
            hdrip->src_ >> Address::instance().NodeShift_[1], 
	    (Scheduler::instance().clock()-hdr->send_time) * 1000);
    Tcl& tcl = Tcl::instance();
    tcl.eval(out);
    // Discard the packet
    Packet::free(pkt);
  }
}