how to send packet back? - c++

Question

I'm writing a new Agent which can be used in one host connected with at least four node.
And the host with traffic generator will send packet to client,after a delay
it will be sended to host again. And the information calculation will be in host.
However, in my test.tcl (only two nodes) the packet receive in client seems didn't
send back to host.
Could somebody give me a hand?
Did the send function any obvious wrong?
Should I assign the ip header or the target_ or anything variables to send back my packet?
AgentCPU.h
#ifndef ns_cpu_h
#define ns_cpu_h
#include <tclcl.h>
#include "agent.h"
#include "config.h"
#include "packet.h"
#include "trafgen.h"
#define SAMPLERATE 8000
struct hdr_task {
int total_time;
int size_;
int number;
int& size() { return size_;}
static int offset_;
inline static int& offset() { return offset_; }
inline static hdr_task* access (const Packet* p) {
return (hdr_task*) p->access(offset_);
}
};
class AgentCPU : public Agent {
public:
AgentCPU();
virtual void recv(Packet *, Handler *);
virtual void sendmsg(int nbytes, const char *flags = 0);
private:
double busy_time_;
float execute_time_;
float execute_time_exp;
double record_packet_Time_;
int npkts_;
};
#endif
AgentCPU.cc
#include "AgentCPU.h"
#include "packet.h"
#include "random.h"
#include "ip.h"
int hdr_task::offset_;
static class TASKHeaderClass : public PacketHeaderClass {
public:
TASKHeaderClass()
:PacketHeaderClass("PacketHeader/TASKHEAD",sizeof(hdr_task)) {
bind_offset(&hdr_task::offset_);
}
} class_task_hdr;
static class CPUClass : public TclClass {
public:
CPUClass() : TclClass("Agent/AgentCPU") {}
TclObject* create(int, const char*const*) {
return (new AgentCPU());
}
} class_cpu_agent;
AgentCPU::AgentCPU() : Agent(PT_TASK)
{
npkts_=0;
record_packet_Time_=0.0;
bind("packetSize_",&size_);
bind("record_packet_Time_",&record_packet_Time_);
bind("npkt_",&npkts_);
}
void AgentCPU::sendmsg(int nbytes, const char* flags)
{
Packet *pkt =allocpkt();
test++;
hdr_cmn *ch = hdr_cmn::access(pkt);
hdr_ip *iph= hdr_ip::access(pkt);
hdr_task *task= hdr_task::access(pkt);
task->number=Random::exponential(5000);
task->state=0;
task->total_time=0;
target_->recv(pkt);
idle();
}
void AgentCPU::recv(Packet* pkt, Handler*)
{
hdr_task *task= hdr_task::access(pkt);
if(task->state==1)
{
if(task->number >2500)
{
task -> total_time += 2500;
task -> number -=2500;
task -> state=0;
// printf("exe 2500 and the packet exe number is %d\n",task->number);
target_->recv(pkt, (Handler*)0);
}
else
{
task ->total_time += task->number ;
task ->number =0;
++npkts_;
record_packet_Time_+= task ->total_time;
Tcl& tcl =Tcl::instance();
Packet::free(pkt);
}
}
else if (task->state==0)
{
int hold_time =Random::exponential(2000);
task->total_time += hold_time;
task->state=1;
Scheduler& s =Scheduler::instance();
double delay = Random::exponential(0.2);
s.schedule(target_,pkt,delay);
}
}
I had tried to modyfied the saddr() and daddr() field in ip header
when I traced the recv packet two field , and the value is 0 and 1
I think they are represent the two node.
So I exchange the two value so the src address and the dest address will exchange
and the packet will be send back to host.
But it results in Seg fault ..

Answer 1

I have solved this problem
I added ip header for the packet I received
hdr_ip* ip=hdr_ip::access(pkt);
ip.daddr()=1; // this int represent the node in your tcl script
However, I have another problem
It will crash when use my tcl script
after use valgrind , the program which can help you detect the memory leak
I know how stupid this question is ,
I guess is the trace format cause this error
ie. I didnt impelment the correct "Trace::format" for my new Packet type
And I didnt comment the trace file code in my tcl script like this
set nf [open out.nam w]
$nf nametrace-all $nf
...
...
And when I comment these code (include the procedure "finish")
All things work! The packet can send to specified node And no Segment Fault
Hope this can help someone who has the same question like me